home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.2 Applications 1996 May / SGI IRIX 6.2 Applications 1996 May.iso / dist / impr_dev.idb / usr / impressario / src / libprintui / PrintBox.c.z / PrintBox.c
C/C++ Source or Header  |  1996-05-06  |  176KB  |  5,996 lines
  1. /**************************************************************************
  2.  *                                      *
  3.  *           Copyright (c)    1991 Silicon Graphics, Inc.          *
  4.  *            All Rights Reserved                    *
  5.  *                                      *
  6.  *       THIS    IS UNPUBLISHED PROPRIETARY SOURCE CODE OF SGI          *
  7.  *                                      *
  8.  * The copyright notice above does not evidence any actual of intended      *
  9.  * publication of such source code, and is an unpublished work by Silicon *
  10.  * Graphics, Inc. This material contains CONFIDENTIAL INFORMATION that is *
  11.  * the property of Silicon Graphics, Inc. Any use, duplication or      *
  12.  * disclosure not specifically authorized by Silicon Graphics is strictly *
  13.  * prohibited.                                  *
  14.  *                                      *
  15.  * RESTRICTED RIGHTS LEGEND:                          *
  16.  *                                      *
  17.  * Use, duplication or disclosure by the Government is subject to      *
  18.  * restrictions as set forth in subdivision (c)(1)(ii) of the Rights in      *
  19.  * Technical Data and Computer Software clause at DFARS 52.227-7013,      *
  20.  * and/or in similar or successor clauses in the FAR, DOD or NASA FAR      *
  21.  * Supplement. Unpublished - rights reserved under the Copyright Laws of  *
  22.  * the United States. Contractor is SILICON GRAPHICS, INC., 2011 N.      *
  23.  * Shoreline Blvd., Mountain View, CA 94039-7311              *
  24.  **************************************************************************
  25.  *
  26.  * File: PrintBox.c
  27.  *
  28.  * Description: Primary implementation file for the PrintBox printing
  29.  *    GUI widget.
  30.  *
  31.  **************************************************************************/
  32.  
  33.  
  34. #ident "$Revision: 1.17 $"
  35.  
  36.  
  37. #include <stdio.h>
  38. #include <stdlib.h>
  39. #include <string.h>
  40. #include <unistd.h>
  41. #include <ctype.h>
  42. #include <bstring.h>
  43. #include <pwd.h>
  44. #include <msgs/uxsgiimpr.h>
  45. #include <X11/StringDefs.h>
  46. #include <X11/cursorfont.h>
  47. #include <Xm/XmP.h>
  48. #include <Xm/Form.h>
  49. #include <Xm/RowColumn.h>
  50. #include <Xm/PushB.h>
  51. #include <Xm/Label.h>
  52. #include <Xm/List.h>
  53. #include <Xm/TextF.h>
  54. #include <Xm/ScrolledW.h>
  55. #include <Xm/ToggleB.h>
  56. #include <Xm/BulletinB.h>
  57. #include <Xm/DialogS.h>
  58. #include <Xm/Separator.h>
  59. #include <Xm/ArrowB.h>
  60. #include <Xm/SelectioB.h>
  61. #include <Sgm/PrintBoxP.h>
  62. #include "PuiI.h"
  63.  
  64.  
  65. /* Misc defines */
  66.  
  67. #define MAX_PNAME    14        /* Max # chars in a printer name */
  68. #define MAX_FORMALNAME    40
  69. #define MAX_LINE    1024        /* General buffer size */
  70.  
  71.  
  72. /* Cursor state enum */
  73.  
  74. typedef enum { PuiCursorBusy, PuiCursorNormal } PuiCursorState;
  75.  
  76.  
  77. /* Class part field macros */
  78.  
  79. #define XPOS(w)            (w)->core.x
  80. #define YPOS(w)            (w)->core.y
  81. #define WIDTH(w)        (w)->core.width
  82. #define HEIGHT(w)        (w)->core.height
  83. #define BWIDTH(w)        (w)->core.border_width
  84. #define MARGIN_WIDTH(w)        (w)->bulletin_board.margin_width
  85. #define MARGIN_HEIGHT(w)    (w)->bulletin_board.margin_height
  86. #define HORIZ_SPACING(w)    MARGIN_WIDTH(w)
  87. #define VERT_SPACING(w)        MARGIN_HEIGHT(w)
  88.  
  89. /* Geometry request macros */
  90.  
  91. #define REQUEST_MODE(req,mask)    (req->request_mode & (mask))
  92.  
  93. /* Resource offset macro */
  94.  
  95. #define offset(field)    XtOffsetOf(PuiPrintBoxRec, field)
  96.  
  97.  
  98. /* Widget method declarations */
  99.  
  100. static void ClassInitialize(void);
  101. static void Initialize(Widget, Widget, ArgList, Cardinal*);
  102. static void Destroy(Widget);
  103. static void ChangeManaged(Widget);
  104. static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry*,
  105.                             XtWidgetGeometry*);
  106. static XtGeometryResult QueryGeometry(Widget, XtWidgetGeometry*,
  107.                             XtWidgetGeometry*);
  108. static void Resize(Widget);
  109. static Boolean SetValues(Widget, Widget, Widget, ArgList, Cardinal*);
  110. static void InsertChild(Widget);
  111. static void DeleteChild(Widget);
  112.  
  113.  
  114. /* Widget private method declarations */
  115.  
  116. /*    UI creation functions */
  117. static void CreateActionArea(PuiPrintBoxWidget);
  118. static void CreateControlArea(PuiPrintBoxWidget);
  119. static void CreateOptionArea(PuiPrintBoxPart*, Widget);
  120. static Widget CreateSaveDialog(PuiPrintBoxWidget);
  121. /*    UI handling functions */
  122. static void UpdateLabel(Widget, String, XmString*);
  123. static void InitTextFieldColors(PuiPrintBoxWidget);
  124. static void SetTextFieldSensitivity(PuiPrintBoxPart*, Widget, Boolean);
  125. static void SetCursor(PuiPrintBoxWidget, PuiCursorState);
  126. /*    General functions */
  127. static void SetFilenames(PuiPrintBoxPart*);
  128. static void SetPrinter(PuiPrintBoxPart*);
  129. static int SetPrinterList(PuiPrintBoxWidget);
  130. static int FindPrinter(PuiPrintBoxPart*, char*);
  131. static void ClearPrinterOptions(PuiPrintBoxPart*);
  132. static void AddPrinterOptions(PuiPrintBoxPart*, char*);
  133. static void SetStringValue(char**, char**, char**);
  134. static void HandleError(PuiPrintBoxWidget, int);
  135. static void FreePrinterList(SLPrinterStruct*, int);
  136. static SLPrinterStruct* CopyPrinterList(SLPrinterStruct*, int);
  137. static void InitCallback(PuiPrintBoxCallbackStruct*);
  138. /*    Widget layout functions */
  139. static void SetOptionsSize(PuiPrintBoxPart*);
  140. static void SetPrinterListSize(PuiPrintBoxPart*);
  141. static void SetActionAreaSize(PuiPrintBoxPart*);
  142. static void DoLayout(PuiPrintBoxWidget);
  143. static void CalculateMySize(PuiPrintBoxWidget, int*, int*);
  144. /*    Settings file handling functions */
  145. static void ReadSpoolerOptionsFile(PuiPrintBoxPart*);
  146. static int WriteSpoolerOptionsFile(PuiPrintBoxWidget);
  147. static char* ReadPrinterOptionsFile(char*);
  148. static void UpdatePrinterOption(PuiPrintBoxWidget, PuiPrinterOption*);
  149. static int WritePrinterOptionsFile(char*, char*, int);
  150. /*    Internal callback functions */
  151. static void PrintSensitiveCB(Widget, XtPointer, XtPointer);
  152. static void PrinterSelectedCB(Widget, XtPointer, XtPointer);
  153. static void SubmitPrintJobCB(Widget, XtPointer, XtPointer);
  154. static void DestroyParentCB(Widget, XtPointer, XtPointer);
  155. static void UnmanageCB(Widget, XtPointer, XtPointer);
  156. static void ActionAreaCB(Widget, XtPointer, XtPointer);
  157. static void QueryForSaveCB(Widget, XtPointer, XtPointer);
  158. static void SaveOptionsCB(Widget, XtPointer, XtPointer);
  159. static void OptionButtonCB(Widget, XtPointer, XtPointer);
  160. static void OptionDataCB(PuiOptionPanel*, XtPointer,
  161.                     PuiOptionPanelCallbackStruct*);
  162. static void OptionMappedCB(PuiOptionPanel*, XtPointer,
  163.                     PuiOptionPanelCallbackStruct*);
  164. static void OptionErrorCB(PuiOptionPanel*, XtPointer,
  165.                     PuiOptionPanelCallbackStruct*);
  166. static void OptionDeathCB(PuiOptionPanel*, XtPointer,
  167.                     PuiOptionPanelCallbackStruct*);
  168.  
  169.  
  170. /* Synthetic resource funtions */
  171. static void SynthGetFilename(Widget, int, XtArgVal*);
  172. static void SynthGetPrinter(Widget, int, XtArgVal*);
  173. static void SynthGetLabel(Widget, int, XtArgVal*);
  174. static void SynthGetButtonSpacing(Widget, int, XtArgVal*);
  175. static void SynthGetVisibleCount(Widget, int, XtArgVal*);
  176.  
  177.  
  178. /* Printing option functions */
  179.  
  180. /*    Number of copies */
  181. static void CreateOptionNumCopies(PuiPrintBoxPart*, Widget);
  182. static void SetOptionNumCopies(PuiPrintBoxPart*);
  183. static void GetOptionNumCopies(PuiPrintBoxPart*);
  184. static void SynthGetOptionNumCopies(Widget, int, XtArgVal*);
  185.  
  186. /*    Banner page */
  187. static void CreateOptionBanner(PuiPrintBoxPart*, Widget);
  188. static void SetOptionBanner(PuiPrintBoxPart*);
  189. static void GetOptionBanner(PuiPrintBoxPart*);
  190. static void SynthGetOptionBanner(Widget, int, XtArgVal*);
  191.  
  192. /*    Job completion notification */
  193. static void CreateOptionCompletion(PuiPrintBoxPart*, Widget);
  194. static void SetOptionCompletion(PuiPrintBoxPart*);
  195. static void GetOptionCompletion(PuiPrintBoxPart*);
  196. static void SynthGetOptionCompletion(Widget, int, XtArgVal*);
  197.  
  198. /*    Print file handling */
  199. static void CreateOptionJobHandling(PuiPrintBoxPart*, Widget);
  200. static void SetOptionJobHandling(PuiPrintBoxPart*);
  201. static void GetOptionJobHandling(PuiPrintBoxPart*);
  202. static void SynthGetOptionJobHandling(Widget, int, XtArgVal*);
  203.  
  204. /*    Printer specific options */
  205. static void CreateOptionPrinterSpecific(PuiPrintBoxPart*, Widget);
  206. static void SetOptionPrinterSpecific(PuiPrintBoxPart*);
  207. static void GetOptionPrinterSpecific(PuiPrintBoxPart*);
  208. static void SynthGetOptionPrinterSpecific(Widget, int, XtArgVal*);
  209.  
  210. /* Printing option structure initialization */
  211.  
  212. static PuiPrintBoxOption option_list[] = {
  213.     {    /* Number of copies */
  214.     CreateOptionNumCopies,
  215.     SetOptionNumCopies,
  216.     GetOptionNumCopies,
  217.     SynthGetOptionNumCopies,
  218.     },
  219.     {    /* Banner page */
  220.     CreateOptionBanner,
  221.     SetOptionBanner,
  222.     GetOptionBanner,
  223.     SynthGetOptionBanner,
  224.     },
  225.     {    /* Job completion */
  226.     CreateOptionCompletion,
  227.     SetOptionCompletion,
  228.     GetOptionCompletion,
  229.     SynthGetOptionCompletion,
  230.     },
  231.     {    /* Job handling */
  232.     CreateOptionJobHandling,
  233.     SetOptionJobHandling,
  234.     GetOptionJobHandling,
  235.     SynthGetOptionJobHandling,
  236.     },
  237.     {    /* Printer specific options */
  238.     CreateOptionPrinterSpecific,
  239.     SetOptionPrinterSpecific,
  240.     GetOptionPrinterSpecific,
  241.     SynthGetOptionPrinterSpecific,
  242.     },
  243. };
  244. static int num_options = sizeof(option_list) / sizeof(PuiPrintBoxOption);
  245.  
  246.  
  247. /* Widget synthetic resource list */
  248.  
  249. static XmSyntheticResource syn_resources[] = {
  250.  
  251.     /* BASIC PRINT JOB INFO ------------------------------------------- */
  252.  
  253.     /* Printer */
  254.     {
  255.     PuiNprinter, sizeof(String),
  256.     offset(printBox.res_printer),
  257.     SynthGetPrinter,
  258.     NULL
  259.     },
  260.         /* Print filename specified as a resource */
  261.     {
  262.     PuiNfilename, sizeof(String),
  263.     offset(printBox.res_filename),
  264.     SynthGetFilename,
  265.     NULL
  266.     },
  267.  
  268.     /* LAYOUT INFO ---------------------------------------------------- */
  269.  
  270.     /* Action area button spacing */
  271.     {
  272.     PuiNbuttonSpacing, sizeof(int),
  273.     offset(printBox.res_button_spacing),
  274.     SynthGetButtonSpacing,
  275.     NULL
  276.     },
  277.     /* Printer list visible item count */
  278.     {
  279.     PuiNlistVisibleItemCount, sizeof(int),
  280.     offset(printBox.res_vis_count),
  281.     SynthGetVisibleCount,
  282.     NULL
  283.     },
  284.  
  285.     /* OPTION RESOURCES ----------------------------------------------- */
  286.  
  287.     /* Number of copies */
  288.     {
  289.     PuiNnumCopies, sizeof(int),
  290.     offset(printBox.res_numcopies),
  291.     SynthGetOptionNumCopies,
  292.     NULL
  293.     },
  294.     /* Copy files */
  295.     {
  296.     PuiNcopy, sizeof(Boolean),
  297.     offset(printBox.res_copy), 
  298.     SynthGetOptionJobHandling,
  299.     NULL
  300.     },
  301.     /* Mail on completion */
  302.     {
  303.     PuiNmail, sizeof(Boolean),
  304.     offset(printBox.res_mail), 
  305.     SynthGetOptionCompletion,
  306.     NULL
  307.     },
  308.     /* Console message on completion */
  309.     {
  310.     PuiNmessage, sizeof(Boolean),
  311.     offset(printBox.res_message),
  312.     SynthGetOptionCompletion,
  313.     NULL
  314.     },
  315.     /* Job title */
  316.     {
  317.     PuiNjobTitle, sizeof(String),
  318.     offset(printBox.res_job_title),
  319.     SynthGetOptionBanner,
  320.     NULL
  321.     },
  322.     /* Printer specific options */
  323.     {
  324.     PuiNprinterOptions, sizeof(String),
  325.     offset(printBox.res_spec_opts),
  326.     SynthGetOptionPrinterSpecific,
  327.     NULL
  328.     },
  329.  
  330.     /* UI LABELING ---------------------------------------------------- */
  331.  
  332.     /* Print button label */
  333.     {
  334.     PuiNprintLabelString, sizeof(XmString),
  335.     offset(printBox.res_printb_label),
  336.     SynthGetLabel, NULL
  337.     },
  338.     /* User defined button 1 label */
  339.     {
  340.     PuiNuser1LabelString, sizeof(XmString),
  341.     offset(printBox.res_user1b_label),
  342.     SynthGetLabel, NULL
  343.     },
  344.     /* User defined button 2 label */
  345.     {
  346.     PuiNuser2LabelString, sizeof(XmString),
  347.     offset(printBox.res_user2b_label),
  348.     SynthGetLabel, NULL
  349.     },
  350.     /* User defined button 3 label */
  351.     {
  352.     PuiNuser3LabelString, sizeof(XmString),
  353.     offset(printBox.res_user3b_label),
  354.     SynthGetLabel, NULL
  355.     },
  356.     /* User defined button 4 label */
  357.     {
  358.     PuiNuser4LabelString, sizeof(XmString),
  359.     offset(printBox.res_user4b_label),
  360.     SynthGetLabel, NULL
  361.     },
  362.     /* Options button label */
  363.     {
  364.     PuiNoptionsbLabelString, sizeof(XmString),
  365.     offset(printBox.res_optionsb_label),
  366.     SynthGetLabel, NULL
  367.     },
  368.     /* Save button label */
  369.     {
  370.     PuiNsaveLabelString, sizeof(XmString),
  371.     offset(printBox.res_saveb_label),
  372.     SynthGetLabel, NULL
  373.     },
  374.     /* Cancel button label */
  375.     {
  376.     PuiNcancelLabelString, sizeof(XmString),
  377.     offset(printBox.res_cancelb_label),
  378.     SynthGetLabel, NULL
  379.     },
  380.     /* Help button label */
  381.     {
  382.     PuiNhelpLabelString, sizeof(XmString),
  383.     offset(printBox.res_helpb_label),
  384.     SynthGetLabel, NULL
  385.     },
  386.     /* Filename label */
  387.     {
  388.     PuiNfilenameLabelString, sizeof(XmString),
  389.     offset(printBox.res_files_label),
  390.     SynthGetLabel, NULL
  391.     },
  392.     /* Print list label */
  393.     {
  394.     PuiNprinterLabelString, sizeof(XmString),
  395.     offset(printBox.res_plist_label),
  396.     SynthGetLabel, NULL
  397.     },
  398.     /* Option list label */
  399.     {
  400.     PuiNoptionLabelString, sizeof(XmString),
  401.     offset(printBox.res_opts_label),
  402.     SynthGetLabel, NULL
  403.     },
  404.     /* Number of copies option label */
  405.     {
  406.     PuiNnumCopiesLabelString, sizeof(XmString),
  407.     offset(printBox.res_numcopies_label),
  408.     SynthGetLabel, NULL
  409.     },
  410.     /* Banner page title option label */
  411.     {
  412.     PuiNjobTitleLabelString, sizeof(XmString),
  413.     offset(printBox.res_title_label),
  414.     SynthGetLabel, NULL
  415.     },
  416.     /* Banner page default title option label */
  417.     {
  418.     PuiNjobDefTitleLabelString, sizeof(XmString),
  419.     offset(printBox.res_deftitle_label),
  420.     SynthGetLabel, NULL
  421.     },
  422.     /* Banner page user specified title option label */
  423.     {
  424.     PuiNjobSpecTitleLabelString, sizeof(XmString),
  425.     offset(printBox.res_spectitle_label),
  426.     SynthGetLabel, NULL
  427.     },
  428.     /* Job completion notification option label */
  429.     {
  430.     PuiNcompletionLabelString, sizeof(XmString),
  431.     offset(printBox.res_complete_label),
  432.     SynthGetLabel, NULL
  433.     },
  434.     /* Notify by mail option label */
  435.     {
  436.     PuiNmailLabelString, sizeof(XmString),
  437.     offset(printBox.res_complete_mail_label),
  438.     SynthGetLabel, NULL
  439.     },
  440.     /* Notify by console message option label */
  441.     {
  442.     PuiNmessageLabelString, sizeof(XmString),
  443.     offset(printBox.res_complete_mess_label),
  444.     SynthGetLabel, NULL
  445.     },
  446.     /* Print job handling option label */
  447.     {
  448.     PuiNhandlingLabelString, sizeof(XmString),
  449.     offset(printBox.res_handling_label),
  450.     SynthGetLabel, NULL
  451.     },
  452.     /* Handle by copying option label */
  453.     {
  454.     PuiNcopyJobLabelString, sizeof(XmString),
  455.     offset(printBox.res_handling_copy_label),
  456.     SynthGetLabel, NULL
  457.     },
  458.     /* Handle by linking option label */
  459.     {
  460.     PuiNlinkJobLabelString, sizeof(XmString),
  461.     offset(printBox.res_handling_link_label),
  462.     SynthGetLabel, NULL
  463.     },
  464.     /* Printer specific options label */
  465.     {
  466.     PuiNprinterSpecLabelString, sizeof(XmString),
  467.     offset(printBox.res_spec_options_label),
  468.     SynthGetLabel, NULL
  469.     },
  470.     /* Save dialog - title label */
  471.     {
  472.     PuiNsaveDlgTitleLabelString, sizeof(XmString),
  473.     offset(printBox.res_savedlg_title_label),
  474.     SynthGetLabel, NULL
  475.     },
  476.     /* Save dialog - Save button label */
  477.     {
  478.     PuiNsaveDlgSaveLabelString, sizeof(XmString),
  479.     offset(printBox.res_savedlg_saveb_label),
  480.     SynthGetLabel, NULL
  481.     },
  482.     /* Save dialog - Save for user button label */
  483.     {
  484.     PuiNsaveDlgUserLabelString, sizeof(XmString),
  485.     offset(printBox.res_savedlg_userb_label),
  486.     SynthGetLabel, NULL
  487.     },
  488.     /* Save dialog - Save for all users button label */
  489.     {
  490.     PuiNsaveDlgAllLabelString, sizeof(XmString),
  491.     offset(printBox.res_savedlg_allb_label),
  492.     SynthGetLabel, NULL
  493.     },
  494.     /* Save dialog - Cancel button label */
  495.     {
  496.     PuiNsaveDlgCancelLabelString, sizeof(XmString),
  497.     offset(printBox.res_savedlg_cancelb_label),
  498.     SynthGetLabel, NULL
  499.     },
  500.     /* Save dialog - message label */
  501.     {
  502.     PuiNsaveDlgMsgLabelString, sizeof(XmString),
  503.     offset(printBox.res_savedlg_msg_label),
  504.     SynthGetLabel, NULL
  505.     },
  506. };
  507.  
  508.  
  509. /* Widget resource list */
  510.  
  511. static XtResource resources[] = {
  512.  
  513.     /* BASIC PRINT JOB INFO ------------------------------------------- */
  514.  
  515.     /* Printer */
  516.     {
  517.     PuiNprinter, PuiCPrinter, XtRString, sizeof(String),
  518.     offset(printBox.res_printer), XtRImmediate, (XtPointer)DEF_PRINTER
  519.     },
  520.         /* Print job type (eg. filename, descriptor, buffer) */
  521.     {
  522.     PuiNjobType, PuiCJobType, XtRInt, sizeof(int),
  523.     offset(printBox.res_job_type), XtRImmediate, (XtPointer)DEF_JOB_TYPE
  524.     },
  525.         /* Print filename specified as a resource */
  526.     {
  527.     PuiNfilename, PuiCFilename, XtRString, sizeof(String),
  528.     offset(printBox.res_filename), XtRImmediate, (XtPointer)DEF_FILENAME
  529.     },
  530.         /* Print file descriptor */
  531.     {
  532.     PuiNfd, PuiCFd, XtRInt, sizeof(int),
  533.     offset(printBox.res_fd), XtRImmediate, (XtPointer)DEF_FD
  534.     },
  535.         /* Print buffer */
  536.     {
  537.     PuiNbuffer, PuiCBuffer, XtRPointer, sizeof(XtPointer),
  538.     offset(printBox.res_buffer), XtRImmediate, (XtPointer)DEF_BUFFER
  539.     },
  540.         /* Print buffer size */
  541.     {
  542.     PuiNbufSize, PuiCBufSize, XtRInt, sizeof(int),
  543.     offset(printBox.res_bufsize), XtRImmediate, (XtPointer)DEF_BUFSIZE
  544.     },
  545.     /* Printing policy */
  546.     {
  547.     PuiNprintingPolicy, PuiCPrintingPolicy,
  548.     PuiRPrintingPolicy, sizeof(int),
  549.     offset(printBox.res_print_policy), XtRImmediate,
  550.                         (XtPointer)DEF_PRINT_POLICY
  551.     },
  552.  
  553.     /* PRINTER INFO (read-only) --------------------------------------- */
  554.  
  555.     /* Available printer list */
  556.     {
  557.     PuiNprinterList, PuiCPrinterList, XtRPointer, sizeof(XtPointer),
  558.     offset(printBox.res_printer_list), XtRImmediate, (XtPointer)NULL
  559.     },
  560.     /* Number of printers in available printer list */
  561.     {
  562.     PuiNnumPrinters, PuiCNumPrinters, XtRInt, sizeof(int),
  563.     offset(printBox.res_num_printers), XtRImmediate, (XtPointer)0
  564.     },
  565.     /* System default printer name */
  566.     {
  567.     PuiNdefPrinter, PuiCDefPrinter, XtRString, sizeof(String),
  568.     offset(printBox.res_default_printer), XtRImmediate, (XtPointer)NULL
  569.     },
  570.  
  571.     /* LOOK AND FEEL INFO -------------------------------------------- */
  572.  
  573.     /* Show filename entry */
  574.     {
  575.     PuiNshowFilename, PuiCShowFilename, XtRBoolean, sizeof(Boolean),
  576.     offset(printBox.res_show_fname), XtRImmediate, (XtPointer)DEF_SHOW_FNAME
  577.     },
  578.     /* Show options */
  579.     {
  580.     PuiNshowOptions, PuiCShowOptions, XtRBoolean, sizeof(Boolean),
  581.     offset(printBox.res_show_opts), XtRImmediate, (XtPointer)DEF_SHOW_OPTS
  582.     },
  583.     /* Show number of copies option */
  584.     {
  585.     PuiNshowNumCopies, PuiCShowNumCopies, XtRBoolean, sizeof(Boolean),
  586.     offset(printBox.res_show_numcopies), XtRImmediate,
  587.     (XtPointer)DEF_SHOW_NUMCOPIES
  588.     },
  589.     /* Show banner page title option */
  590.     {
  591.     PuiNshowBannerTitle, PuiCShowBannerTitle, XtRBoolean, sizeof(Boolean),
  592.     offset(printBox.res_show_bannertitle), XtRImmediate,
  593.     (XtPointer)DEF_SHOW_BANNERTITLE
  594.     },
  595.     /* Show completion notification option */
  596.     {
  597.     PuiNshowCompletion, PuiCShowCompletion, XtRBoolean, sizeof(Boolean),
  598.     offset(printBox.res_show_completion), XtRImmediate,
  599.     (XtPointer)DEF_SHOW_COMPLETION
  600.     },
  601.     /* Show job handling option */
  602.     {
  603.     PuiNshowHandling, PuiCShowHandling, XtRBoolean, sizeof(Boolean),
  604.     offset(printBox.res_show_handling), XtRImmediate,
  605.     (XtPointer)DEF_SHOW_HANDLING
  606.     },
  607.     /* Show printer specific options */
  608.     {
  609.     PuiNshowPrinterOptions, PuiCShowPrinterOptions, XtRBoolean,
  610.     sizeof(Boolean),
  611.     offset(printBox.res_show_printeroptions), XtRImmediate,
  612.     (XtPointer)DEF_SHOW_PRINTEROPTIONS
  613.     },
  614.     /* Show Options button */
  615.     {
  616.     PuiNshowOptionsButton, PuiCShowOptionsButton, XtRBoolean,
  617.     sizeof(Boolean), offset(printBox.res_show_optionsbutton), XtRImmediate,
  618.     (XtPointer)DEF_SHOW_OPTIONSBUTTON
  619.     },
  620.     /* Show Save button */
  621.     {
  622.     PuiNshowSaveButton, PuiCShowSaveButton, XtRBoolean,
  623.     sizeof(Boolean), offset(printBox.res_show_savebutton), XtRImmediate,
  624.     (XtPointer)DEF_SHOW_SAVEBUTTON
  625.     },
  626.     /* Action area button placement */
  627.     {
  628.     PuiNbuttonPlacement, PuiCButtonPlacement, PuiRButtonPlacement,
  629.     sizeof(int), offset(printBox.res_button_placement),
  630.     XtRImmediate, (XtPointer)DEF_BUTTON_PLACEMENT
  631.     },
  632.     /* Action area button spacing */
  633.     {
  634.     PuiNbuttonSpacing, PuiCButtonSpacing, XtRInt, sizeof(int),
  635.     offset(printBox.res_button_spacing),
  636.     XtRImmediate, (XtPointer)DEF_BUTTON_SPACING
  637.     },
  638.     /* Printer list visible item count */
  639.     {
  640.     PuiNlistVisibleItemCount, PuiCVisibleItemCount, XtRInt, sizeof(int),
  641.     offset(printBox.res_vis_count), XtRImmediate, (XtPointer)DEF_VIS_COUNT
  642.     },
  643.     /* Printer list printer font */
  644.     {
  645.     PuiNprinterFont, PuiCFont, XtRFontStruct,
  646.     sizeof(XFontStruct*), offset(printBox.res_printer_font), XtRString,
  647.     DEF_PRINTER_FONT
  648.     },
  649.     /* Printer list default printer font */
  650.     {
  651.     PuiNdefaultPrinterFont, PuiCFont, XtRFontStruct,
  652.     sizeof(XFontStruct*), offset(printBox.res_def_printer_font), XtRString,
  653.     DEF_DEFAULT_PRINTER_FONT
  654.     },
  655.     /* Busy Cursor */
  656.     {
  657.     PuiNbusyCursor, PuiCCursor, XtRCursor, sizeof(Cursor),
  658.     offset(printBox.res_busy_cursor), XtRString, DEF_BUSY_CURSOR
  659.     },
  660.  
  661.     /* TEXT FIELD SENSITIVITY ---------------------------------------- */
  662.  
  663.     /* Text field insensitive foreground color */
  664.     {
  665.     PuiNinsensitiveForeground, PuiCForeground, XtRPixel, sizeof(Pixel),
  666.     offset(printBox.tfield_insensitive.foreground), XtRString,
  667.     (XtPointer)DEF_INSENSITIVE_FORE
  668.     },
  669.     /* Text field insensitive background color */
  670.     {
  671.     PuiNinsensitiveBackground, PuiCBackground, XtRPixel, sizeof(Pixel),
  672.     offset(printBox.tfield_insensitive.background), XtRString,
  673.     (XtPointer)DEF_INSENSITIVE_BACK
  674.     },
  675.     /* Filename field sensitivity */
  676.     {
  677.     PuiNfilenameSensitive, PuiCSensitive, XtRBoolean, sizeof(Boolean),
  678.     offset(printBox.res_filename_sensitive), XtRImmediate, (XtPointer)True
  679.     },
  680.     /* Number of copies field sensitivity */
  681.     {
  682.     PuiNnumCopiesSensitive, PuiCSensitive, XtRBoolean, sizeof(Boolean),
  683.     offset(printBox.res_numcopies_sensitive), XtRImmediate, (XtPointer)True
  684.     },
  685.     /* Printer options field sensitivity */
  686.     {
  687.     PuiNprinterOptionsSensitive, PuiCSensitive, XtRBoolean, sizeof(Boolean),
  688.     offset(printBox.res_poptions_sensitive), XtRImmediate, (XtPointer)True
  689.     },
  690.  
  691.     /* CALLBACKS ---------------------------------------------------- */
  692.  
  693.     /* Print button callback */
  694.     {
  695.     PuiNprintCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  696.     offset(printBox.res_print_callback), XtRImmediate, (XtPointer)NULL
  697.     },
  698.     /* User1 button callback */
  699.     {
  700.     PuiNuser1Callback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  701.     offset(printBox.res_user1_callback), XtRImmediate, (XtPointer)NULL
  702.     },
  703.     /* User2 button callback */
  704.     {
  705.     PuiNuser2Callback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  706.     offset(printBox.res_user2_callback), XtRImmediate, (XtPointer)NULL
  707.     },
  708.     /* User3 button callback */
  709.     {
  710.     PuiNuser3Callback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  711.     offset(printBox.res_user3_callback), XtRImmediate, (XtPointer)NULL
  712.     },
  713.     /* User4 button callback */
  714.     {
  715.     PuiNuser4Callback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  716.     offset(printBox.res_user4_callback), XtRImmediate, (XtPointer)NULL
  717.     },
  718.     /* Save button callback */
  719.     {
  720.     PuiNsaveCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  721.     offset(printBox.res_save_callback), XtRImmediate, (XtPointer)NULL
  722.     },
  723.     /* Cancel button callback */
  724.     {
  725.     PuiNcancelCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  726.     offset(printBox.res_cancel_callback), XtRImmediate, (XtPointer)NULL
  727.     },
  728.     /* Help button callback */
  729.     {
  730.     PuiNhelpCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  731.     offset(printBox.res_help_callback), XtRImmediate, (XtPointer)NULL
  732.     },
  733.     /* Print job information callback */
  734.     {
  735.     PuiNjobInfoCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  736.     offset(printBox.res_jobinfo_callback), XtRImmediate, (XtPointer)NULL
  737.     },
  738.     /* Printer selection callback */
  739.     {
  740.     PuiNprinterSelectCallback, PuiCCallback, XtRCallback,
  741.     sizeof(XtCallbackList),
  742.     offset(printBox.res_pr_select_callback), XtRImmediate, (XtPointer)NULL
  743.     },
  744.     /* Printer action callback */
  745.     {
  746.     PuiNprinterActionCallback, PuiCCallback, XtRCallback,
  747.     sizeof(XtCallbackList),
  748.     offset(printBox.res_pr_action_callback), XtRImmediate, (XtPointer)NULL
  749.     },
  750.     /* Error callback */
  751.     {
  752.     PuiNerrorCallback, PuiCCallback, XtRCallback, sizeof(XtCallbackList),
  753.     offset(printBox.res_error_callback), XtRImmediate, (XtPointer)NULL
  754.     },
  755.     /* Option panel error callback */
  756.     {
  757.     PuiNoptionErrorCallback, PuiCCallback, XtRCallback,
  758.     sizeof(XtCallbackList),
  759.     offset(printBox.res_opt_error_callback), XtRImmediate, (XtPointer)NULL
  760.     },
  761.  
  762.     /* UI LABELING -------------------------------------------------- */
  763.  
  764.     /* Print button label */
  765.     {
  766.     PuiNprintLabelString, PuiCPrintLabelString, XmRXmString,
  767.     sizeof(XmString), offset(printBox.res_printb_label), XtRString,
  768.     (XtPointer)NULL
  769.     },
  770.     /* User defined button 1 label */
  771.     {
  772.     PuiNuser1LabelString, PuiCUser1LabelString, XmRXmString,
  773.     sizeof(XmString), offset(printBox.res_user1b_label), XtRString,
  774.     (XtPointer)NULL
  775.     },
  776.     /* User defined button 2 label */
  777.     {
  778.     PuiNuser2LabelString, PuiCUser2LabelString, XmRXmString,
  779.     sizeof(XmString), offset(printBox.res_user2b_label), XtRString,
  780.     (XtPointer)NULL
  781.     },
  782.     /* User defined button 3 label */
  783.     {
  784.     PuiNuser3LabelString, PuiCUser3LabelString, XmRXmString,
  785.     sizeof(XmString), offset(printBox.res_user3b_label), XtRString,
  786.     (XtPointer)NULL
  787.     },
  788.     /* User defined button 4 label */
  789.     {
  790.     PuiNuser4LabelString, PuiCUser4LabelString, XmRXmString,
  791.     sizeof(XmString), offset(printBox.res_user4b_label), XtRString,
  792.     (XtPointer)NULL
  793.     },
  794.     /* Options button label */
  795.     {
  796.     PuiNoptionsbLabelString, PuiCOptionsbLabelString, XmRXmString,
  797.     sizeof(XmString), offset(printBox.res_optionsb_label), XtRString,
  798.     (XtPointer)NULL
  799.     },
  800.     /* Save button label */
  801.     {
  802.     PuiNsaveLabelString, PuiCSaveLabelString, XmRXmString,
  803.     sizeof(XmString), offset(printBox.res_saveb_label), XtRString,
  804.     (XtPointer)NULL
  805.     },
  806.     /* Cancel button label */
  807.     {
  808.     PuiNcancelLabelString, PuiCCancelLabelString, XmRXmString,
  809.     sizeof(XmString), offset(printBox.res_cancelb_label), XtRString,
  810.     (XtPointer)NULL
  811.     },
  812.     /* Help button label */
  813.     {
  814.     PuiNhelpLabelString, PuiCHelpLabelString, XmRXmString,
  815.     sizeof(XmString), offset(printBox.res_helpb_label), XtRString,
  816.     (XtPointer)NULL
  817.     },
  818.     /* Filename label */
  819.     {
  820.     PuiNfilenameLabelString, PuiCFilenameLabelString, XmRXmString,
  821.     sizeof(XmString), offset(printBox.res_files_label), XtRString,
  822.     (XtPointer)NULL
  823.     },
  824.     /* Printer list label */
  825.     {
  826.     PuiNprinterLabelString, PuiCPrinterLabelString, XmRXmString,
  827.     sizeof(XmString), offset(printBox.res_plist_label), XtRString,
  828.     (XtPointer)NULL
  829.     },
  830.     /* Option list label */
  831.     {
  832.     PuiNoptionLabelString, PuiCOptionLabelString, XmRXmString,
  833.     sizeof(XmString), offset(printBox.res_opts_label), XtRString,
  834.     (XtPointer)NULL
  835.     },
  836.     /* Number of copies option label */
  837.     {
  838.     PuiNnumCopiesLabelString, PuiCNumCopiesLabelString, XmRXmString,
  839.     sizeof(XmString), offset(printBox.res_numcopies_label), XtRString,
  840.     (XtPointer)NULL
  841.     },
  842.     /* Banner page title option label */
  843.     {
  844.     PuiNjobTitleLabelString, PuiCJobTitleLabelString, XmRXmString,
  845.     sizeof(XmString), offset(printBox.res_title_label), XtRString,
  846.     (XtPointer)NULL
  847.     },
  848.     /* Banner page default title option label */
  849.     {
  850.     PuiNjobDefTitleLabelString, PuiCJobDefTitleLabelString, XmRXmString,
  851.     sizeof(XmString), offset(printBox.res_deftitle_label), XtRString,
  852.     (XtPointer)NULL
  853.     },
  854.     /* Banner page user specified title option label */
  855.     {
  856.     PuiNjobSpecTitleLabelString, PuiCJobSpecTitleLabelString, XmRXmString,
  857.     sizeof(XmString), offset(printBox.res_spectitle_label), XtRString,
  858.     (XtPointer)NULL
  859.     },
  860.     /* Job completion notification option label */
  861.     {
  862.     PuiNcompletionLabelString, PuiCCompletionLabelString, XmRXmString,
  863.     sizeof(XmString), offset(printBox.res_complete_label), XtRString,
  864.     (XtPointer)NULL
  865.     },
  866.     /* Notify by mail option label */
  867.     {
  868.     PuiNmailLabelString, PuiCMailLabelString, XmRXmString,
  869.     sizeof(XmString), offset(printBox.res_complete_mail_label), XtRString,
  870.     (XtPointer)NULL
  871.     },
  872.     /* Notify by console message option label */
  873.     {
  874.     PuiNmessageLabelString, PuiCMessageLabelString, XmRXmString,
  875.     sizeof(XmString), offset(printBox.res_complete_mess_label), XtRString,
  876.     (XtPointer)NULL
  877.     },
  878.     /* Print job handling option label */
  879.     {
  880.     PuiNhandlingLabelString, PuiCHandlingLabelString, XmRXmString,
  881.     sizeof(XmString), offset(printBox.res_handling_label), XtRString,
  882.     (XtPointer)NULL
  883.     },
  884.     /* Handle by copying option label */
  885.     {
  886.     PuiNcopyJobLabelString, PuiCCopyJobLabelString, XmRXmString,
  887.     sizeof(XmString), offset(printBox.res_handling_copy_label), XtRString,
  888.     (XtPointer)NULL
  889.     },
  890.     /* Handle by linking option label */
  891.     {
  892.     PuiNlinkJobLabelString, PuiCLinkJobLabelString, XmRXmString,
  893.     sizeof(XmString), offset(printBox.res_handling_link_label), XtRString,
  894.     (XtPointer)NULL
  895.     },
  896.     /* Printer specific options label */
  897.     {
  898.     PuiNprinterSpecLabelString, PuiCPrinterSpecLabelString, XmRXmString,
  899.     sizeof(XmString), offset(printBox.res_spec_options_label), XtRString,
  900.     (XtPointer)NULL
  901.     },
  902.     /* Save dialog - dialog title label */
  903.     {
  904.     PuiNsaveDlgTitleLabelString, PuiCSaveDlgTitleLabelString, XmRXmString,
  905.     sizeof(XmString), offset(printBox.res_savedlg_title_label), XtRString,
  906.     (XtPointer)DEF_SAVEDLGTITLE_LABEL
  907.     },
  908.     /* Save dialog - Save button label */
  909.     {
  910.     PuiNsaveDlgSaveLabelString, PuiCSaveDlgSaveLabelString, XmRXmString,
  911.     sizeof(XmString), offset(printBox.res_savedlg_saveb_label), XtRString,
  912.     (XtPointer)DEF_SAVEDLGSAVE_LABEL
  913.     },
  914.     /* Save dialog - Save for user button label */
  915.     {
  916.     PuiNsaveDlgUserLabelString, PuiCSaveDlgUserLabelString, XmRXmString,
  917.     sizeof(XmString), offset(printBox.res_savedlg_userb_label), XtRString,
  918.     (XtPointer)DEF_SAVEDLGUSER_LABEL
  919.     },
  920.     /* Save dialog - Save for all users button label */
  921.     {
  922.     PuiNsaveDlgAllLabelString, PuiCSaveDlgAllLabelString, XmRXmString,
  923.     sizeof(XmString), offset(printBox.res_savedlg_allb_label), XtRString,
  924.     (XtPointer)DEF_SAVEDLGALL_LABEL
  925.     },
  926.     /* Save dialog - Cancel button label */
  927.     {
  928.     PuiNsaveDlgCancelLabelString, PuiCSaveDlgCancelLabelString, XmRXmString,
  929.     sizeof(XmString), offset(printBox.res_savedlg_cancelb_label), XtRString,
  930.     (XtPointer)DEF_SAVEDLGCANCEL_LABEL
  931.     },
  932.     /* Save dialog - message label */
  933.     {
  934.     PuiNsaveDlgMsgLabelString, PuiCSaveDlgMsgLabelString, XmRXmString,
  935.     sizeof(XmString), offset(printBox.res_savedlg_msg_label), XtRString,
  936.     (XtPointer)DEF_SAVEDLGMSG_LABEL
  937.     },
  938.  
  939.     /* OPTIONS -------------------------------------------------------- */
  940.  
  941.     /* Number of copies */
  942.     {
  943.     PuiNnumCopies, PuiCNumCopies, XtRInt, sizeof(int),
  944.     offset(printBox.res_numcopies), XtRImmediate, (XtPointer)DEF_NUM_COPIES
  945.     },
  946.     /* Copy files */
  947.     {
  948.     PuiNcopy, PuiCCopy, XtRBoolean, sizeof(Boolean),
  949.     offset(printBox.res_copy), XtRImmediate, (XtPointer)DEF_COPY
  950.     },
  951.     /* Mail on completion */
  952.     {
  953.     PuiNmail, PuiCMail, XtRBoolean, sizeof(Boolean),
  954.     offset(printBox.res_mail), XtRImmediate, (XtPointer)DEF_MAIL
  955.     },
  956.     /* Console message on completion */
  957.     {
  958.     PuiNmessage, PuiCMessage, XtRBoolean, sizeof(Boolean),
  959.     offset(printBox.res_message), XtRImmediate, (XtPointer)DEF_MESSAGE
  960.     },
  961.     /* Job title */
  962.     {
  963.     PuiNjobTitle, PuiCJobTitle, XtRString, sizeof(String),
  964.     offset(printBox.res_job_title), XtRImmediate, (XtPointer)DEF_JOB_TITLE
  965.     },
  966.     /* Printer specific options */
  967.     {
  968.     PuiNprinterOptions, PuiCPrinterOptions, XtRString, sizeof(String),
  969.     offset(printBox.res_spec_opts), XtRImmediate, (XtPointer)DEF_SPEC_OPTS
  970.     },
  971. };
  972.  
  973.  
  974. /* Core record initialization */
  975.  
  976. PuiPrintBoxClassRec puiPrintBoxClassRec = {
  977.     {        /* Core class fields */
  978.     /* superclass */        (WidgetClass) &xmBulletinBoardClassRec,
  979.     /* class_name */        "PuiPrintBox",
  980.     /* widget_size */        sizeof(PuiPrintBoxRec),
  981.     /* class_initialize */        ClassInitialize,
  982.     /* class_part_initialize */    NULL,
  983.     /* class_inited */        False,
  984.     /* initialize */        Initialize,
  985.     /* initialize_hook */        NULL,
  986.     /* realize */            XtInheritRealize,
  987.     /* actions */            NULL,
  988.     /* num_actions */        0,
  989.     /* resources */            resources,
  990.     /* num_resources */        XtNumber(resources),
  991.     /* xrm_class */            NULLQUARK,
  992.     /* compress_motion */        True,
  993.     /* compress_exposure */        True,
  994.     /* compress_enterleave */    True,
  995.     /* visible_interest */        False,
  996.     /* destroy */            Destroy,
  997.     /* resize */            Resize,
  998.     /* expose */            XtInheritExpose,
  999.     /* set_values */        SetValues,
  1000.     /* set_values_hook */        NULL,
  1001.     /* set_values_almost */        XtInheritSetValuesAlmost,
  1002.     /* get_values_hook */        NULL,
  1003.     /* accept_focus */        NULL,
  1004.     /* version */            XtVersion,
  1005.     /* callback_private */        NULL,
  1006.     /* tm_table */            XtInheritTranslations,
  1007.     /* query_geometry */        QueryGeometry,
  1008.     /* display_accelerator */    XtInheritDisplayAccelerator,
  1009.     /* extension */            NULL,
  1010.     },
  1011.     {        /* Composite class fields */
  1012.     /* geometry_manager */        GeometryManager,
  1013.     /* change_managed */        ChangeManaged,
  1014.     /* insert_child */        InsertChild,
  1015.     /* delete_child */        DeleteChild,
  1016.     /* extension */            NULL,
  1017.     },
  1018.     {        /* Constraint class fields */
  1019.     /* no additional resources */    NULL,
  1020.     /* num additional resources */    0,
  1021.     /* size of constraint rec */    0,
  1022.     /* constraint_initialize */    NULL,
  1023.     /* constraint_destroy */    NULL,
  1024.     /* constraint_setvalue */    NULL,
  1025.     /* extension */            NULL,
  1026.     },
  1027.     {        /* XmManager class fields */
  1028.     /* default translations */    XmInheritTranslations,
  1029.     /* syn_resources */        syn_resources,
  1030.     /* num_syn_resources */        XtNumber(syn_resources),
  1031.     /* syn_cont_resources */    NULL,
  1032.     /* num_syn_cont_resources */    0,
  1033.     /* parent_process */        XmInheritParentProcess,
  1034.     /* extension */            NULL,
  1035.     },
  1036.     {        /* XmBulletinBoard class fields */
  1037.     /* always_install_accelerators */    TRUE,
  1038.     /* geo_matrix_create */        XmInheritGeoMatrixCreate,
  1039.     /* focus_moved_proc */        XmInheritFocusMovedProc,
  1040.     /* extension */            NULL,
  1041.     },
  1042.     {        /* PuiPrintBox class fields */
  1043.     /* dummy */            NULL,
  1044.     }
  1045. };
  1046.  
  1047. WidgetClass puiPrintBoxWidgetClass = (WidgetClass) &puiPrintBoxClassRec;
  1048.  
  1049.  
  1050. /*
  1051.  ==========================================================================
  1052.             STANDARD WIDGET METHODS
  1053.  ==========================================================================
  1054. */
  1055.  
  1056.  
  1057. /**************************************************************************
  1058.  *
  1059.  * Function: ClassInitialize
  1060.  *
  1061.  * Description: Initialize method for the class.
  1062.  *
  1063.  * Parameters: none
  1064.  *
  1065.  * Return: none
  1066.  *
  1067.  **************************************************************************/
  1068.  
  1069. static void ClassInitialize(void)
  1070. {
  1071.     /*
  1072.      * Register the printing policy resource converter
  1073.      */
  1074.     XtSetTypeConverter(XtRString, PuiRPrintingPolicy,
  1075.             PuiCvtStringToPrintingPolicy,
  1076.             (XtConvertArgList)NULL, 0,
  1077.             XtCacheNone, NULL);
  1078.     /*
  1079.      * Register the button placement resource converter
  1080.      */
  1081.     XtSetTypeConverter(XtRString, PuiRButtonPlacement,
  1082.             PuiCvtStringToButtonPlacement,
  1083.             (XtConvertArgList)NULL, 0,
  1084.             XtCacheNone, NULL);
  1085. }
  1086.  
  1087.  
  1088. /**************************************************************************
  1089.  *
  1090.  * Function: Initialize
  1091.  *
  1092.  * Description: Widget initialization method
  1093.  *
  1094.  * Parameters: 
  1095.  *    treq (I) - widget as set by arg list, resource database and defaults
  1096.  *    tnew (I) - new widget
  1097.  *    args (I) - argument list in Va creation
  1098.  *    num_args (I) - number of arguments
  1099.  *
  1100.  * Return: none
  1101.  *
  1102.  **************************************************************************/
  1103. /* ARGSUSED */
  1104.  
  1105. static void Initialize(Widget treq, Widget tnew,
  1106.                     ArgList args, Cardinal *num_args)
  1107. {
  1108.     PuiPrintBoxWidget new = (PuiPrintBoxWidget)tnew;
  1109.     PuiPrintBoxWidget req = (PuiPrintBoxWidget)treq;
  1110.     PuiPrintBoxPart *pbp = &new->printBox;
  1111.     register int i;
  1112.     struct passwd *user_pw;
  1113.  
  1114.     /*
  1115.      * Set some arbitrary intial size the actual initial size
  1116.      * will be determined in the ChangeManaged routine.
  1117.      */
  1118.     if (WIDTH(req) <= 0)
  1119.     WIDTH(new) = 5;
  1120.     if (HEIGHT(req) <= 0)
  1121.     HEIGHT(new) = 5;
  1122.  
  1123.     /*
  1124.      * Determine who the user is
  1125.      */
  1126.     if ((user_pw = getpwuid(getuid())) == NULL) {
  1127.     char buf[30];
  1128.     sprintf(buf, "uid%u", getuid());
  1129.     pbp->user_name = strdup(buf);
  1130.     } else
  1131.     pbp->user_name = strdup(user_pw->pw_name);
  1132.  
  1133.     /*
  1134.      * Initialize printer selection instance variables and
  1135.      * printer specific options variables.
  1136.      */
  1137.     pbp->res_num_printers = 0;
  1138.     pbp->res_printer_list = NULL;
  1139.     pbp->res_default_printer = NULL;
  1140.     pbp->selected_printer_index = -1;
  1141.     pbp->printer_options = NULL;
  1142.  
  1143.     /*
  1144.      * Initialize job submittal option variables
  1145.      */
  1146.     pbp->num_copies = 1;
  1147.     pbp->copy_file = 0;
  1148.     pbp->mail = 0;
  1149.     pbp->options = NULL;
  1150.     pbp->job_title = NULL;
  1151.  
  1152.     /*
  1153.      * Initialize instance widget variables
  1154.      */
  1155.     pbp->printb_widget = NULL;
  1156.     pbp->user1b_widget = NULL;
  1157.     pbp->user2b_widget = NULL;
  1158.     pbp->user3b_widget = NULL;
  1159.     pbp->user4b_widget = NULL;
  1160.     pbp->optionsb_widget = NULL;
  1161.     pbp->saveb_widget = NULL;
  1162.     pbp->cancelb_widget = NULL;
  1163.     pbp->helpb_widget = NULL;
  1164.     pbp->files_label_widget = NULL;
  1165.     pbp->plist_label_widget = NULL;
  1166.     pbp->opts_label_widget = NULL;
  1167.     pbp->files_widget = NULL;
  1168.     pbp->plist_widget = NULL;
  1169.     pbp->pf_form = NULL;
  1170.     pbp->option_form = NULL;
  1171.     pbp->action_form = NULL;
  1172.     pbp->action_rc = NULL;
  1173.     pbp->opts_rc_widget = NULL;
  1174.     pbp->opts_sw_widget = NULL;
  1175.     pbp->work_area = NULL;
  1176.     pbp->separator = NULL;
  1177.     pbp->numcopies_label_widget = NULL;
  1178.     pbp->title_label_widget = NULL;
  1179.     pbp->complete_label_widget = NULL;
  1180.     pbp->handling_label_widget = NULL;
  1181.     pbp->spec_options_label_widget = NULL;
  1182.     pbp->save_dialog_widget = NULL;
  1183.     pbp->save_list_widget = NULL;
  1184.     pbp->save_msg_widget = NULL;
  1185.  
  1186.     /*
  1187.      * For my resources that are strings I need to make copies
  1188.      * so that the user can free storage for any string he passes
  1189.      * in
  1190.      */
  1191.     if (pbp->res_printer)
  1192.     pbp->res_printer = XtNewString(pbp->res_printer);
  1193.     if (pbp->res_filename)
  1194.     pbp->res_filename = XtNewString(pbp->res_filename);
  1195.     if (pbp->res_job_title)
  1196.     pbp->res_job_title = XtNewString(pbp->res_job_title);
  1197.     if (pbp->res_spec_opts)
  1198.     pbp->res_spec_opts = XtNewString(pbp->res_spec_opts);
  1199.  
  1200.     /*
  1201.      * Indicate that we are adding our own child widgets
  1202.      */
  1203.     pbp->adding_pb_widgets = True;
  1204.  
  1205.     /*
  1206.      * Create the major dialog UI areas
  1207.      */
  1208.     CreateControlArea(new);
  1209.     CreateActionArea(new);
  1210.  
  1211.     /*
  1212.      * Create the save options dialog. Note that we cannot lazy
  1213.      * evaluate the dialog creation since we need to have the
  1214.      * dialog around for label resource queries.
  1215.      */
  1216.     pbp->save_dialog_widget = CreateSaveDialog(new);
  1217.  
  1218.     /*
  1219.      * Indicate that we are no longer adding widgets
  1220.      */
  1221.     pbp->adding_pb_widgets = False;
  1222.  
  1223.     /*
  1224.      * Initialize text field foreground, background and shadow color instance
  1225.      * entries for use in making the text fields insensitive. Then
  1226.      * make sure everything starts off with the desired sensitivity.
  1227.      */
  1228.     InitTextFieldColors(new);
  1229.     SetTextFieldSensitivity(pbp, pbp->files_widget,
  1230.                         pbp->res_filename_sensitive);
  1231.     SetTextFieldSensitivity(pbp, pbp->numcopies_text_widget,
  1232.                         pbp->res_numcopies_sensitive);
  1233.     SetTextFieldSensitivity(pbp, pbp->spec_options_widget,
  1234.                         pbp->res_poptions_sensitive);
  1235.  
  1236.     /*
  1237.      * Initialize the option objects
  1238.      */
  1239.     for (i = 0; i < num_options; i++)
  1240.     option_list[i].set_func(pbp);
  1241.  
  1242.     /*
  1243.      * Read the spooling system options and set the UI accordingly.
  1244.      * Note that we do this after setting the UI from the resources
  1245.      * so that the glprc file settings take precedence over the
  1246.      * resources set when the widget is created. Any subsequent set
  1247.      * values on the resource will then override the glprc setting.
  1248.      */
  1249.     ReadSpoolerOptionsFile(pbp);
  1250.  
  1251.     /*
  1252.      * Set the spooler to System V and set the list of printers.
  1253.      */
  1254.     pbp->init_error_code = 0;
  1255.     if (SLSetSpooler(SL_SPOOLER_SYSV) < 0)
  1256.     pbp->init_error_code = SLerrno;
  1257.     else
  1258.         pbp->init_error_code = SetPrinterList(new);
  1259.  
  1260.     /*
  1261.      * Initialize the option panel array
  1262.      */
  1263.     pbp->option_panels = NULL;
  1264.     if (pbp->res_show_optionsbutton && pbp->res_num_printers > 0) {
  1265.     pbp->option_panels = (PuiOptionPanel**)XtCalloc(pbp->res_num_printers,
  1266.                         sizeof(PuiOptionPanel*));
  1267.     }
  1268.  
  1269.     /*
  1270.      * Select the appropriate printer
  1271.      */
  1272.     SetPrinter(pbp);
  1273.  
  1274.     /*
  1275.      * Initialize the filename
  1276.      */
  1277.     SetFilenames(pbp);
  1278.  
  1279.     /*
  1280.      * A number of the string resources we support are actually fronts
  1281.      * for our children widgets. We will let the children maintain the
  1282.      * state of these resources and we will query the children when we
  1283.      * get a GetValues for these resources. Normally we will keep these
  1284.      * resources set to NULL on our side.
  1285.      */
  1286.     pbp->res_printb_label = NULL;
  1287.     pbp->res_user1b_label = NULL;
  1288.     pbp->res_user2b_label = NULL;
  1289.     pbp->res_user3b_label = NULL;
  1290.     pbp->res_user4b_label = NULL;
  1291.     pbp->res_optionsb_label = NULL;
  1292.     pbp->res_saveb_label = NULL;
  1293.     pbp->res_cancelb_label = NULL;
  1294.     pbp->res_helpb_label = NULL;
  1295.     pbp->res_files_label = NULL;
  1296.     pbp->res_plist_label = NULL;
  1297.     pbp->res_opts_label = NULL;
  1298.     pbp->res_numcopies_label = NULL;
  1299.     pbp->res_title_label = NULL;
  1300.     pbp->res_deftitle_label = NULL;
  1301.     pbp->res_spectitle_label = NULL;
  1302.     pbp->res_complete_label = NULL;
  1303.     pbp->res_complete_mail_label = NULL;
  1304.     pbp->res_complete_mess_label = NULL;
  1305.     pbp->res_handling_label = NULL;
  1306.     pbp->res_handling_copy_label = NULL;
  1307.     pbp->res_handling_link_label = NULL;
  1308.     pbp->res_spec_options_label = NULL;
  1309.     pbp->res_savedlg_title_label = NULL;
  1310.     pbp->res_savedlg_saveb_label = NULL;
  1311.     pbp->res_savedlg_userb_label = NULL;
  1312.     pbp->res_savedlg_allb_label = NULL;
  1313.     pbp->res_savedlg_cancelb_label = NULL;
  1314.     pbp->res_savedlg_msg_label = NULL;
  1315. }
  1316.  
  1317.  
  1318. /**************************************************************************
  1319.  *
  1320.  * Function: Destroy
  1321.  *
  1322.  * Description: Cleans up local allocations
  1323.  *
  1324.  * Parameters: 
  1325.  *    w (I) - this widget
  1326.  *
  1327.  * Return: none
  1328.  *
  1329.  **************************************************************************/
  1330.  
  1331. static void Destroy(Widget w)
  1332. {
  1333.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)w;
  1334.     PuiPrintBoxPart *pbp = &pb->printBox;
  1335.     register int i;
  1336.  
  1337.     /*
  1338.      * Destroy all option panel instances and free the lsit
  1339.      */
  1340.     if (pbp->option_panels) {
  1341.         for (i = 0; i < pbp->res_num_printers; i++)
  1342.         if (pbp->option_panels[i])
  1343.         _PuiOptionPanelDestroy(pbp->option_panels[i]);
  1344.         XtFree((char*)pbp->option_panels);
  1345.     }
  1346.  
  1347.     /*
  1348.      * Free the printer list
  1349.      */
  1350.     FreePrinterList(pbp->res_printer_list, pbp->res_num_printers);
  1351.  
  1352.     /*
  1353.      * Deallocate string storage
  1354.      */
  1355.     if (pbp->res_printer)
  1356.     XtFree(pbp->res_printer);
  1357.     if (pbp->res_filename)
  1358.     XtFree(pbp->res_filename);
  1359.     if (pbp->res_job_title)
  1360.     XtFree(pbp->res_job_title);
  1361.     if (pbp->res_spec_opts)
  1362.     XtFree(pbp->res_spec_opts);
  1363.  
  1364.     /*
  1365.      * Remove all callbacks
  1366.      */
  1367.     XtRemoveAllCallbacks(w, PuiNprintCallback);
  1368.     XtRemoveAllCallbacks(w, PuiNuser1Callback);
  1369.     XtRemoveAllCallbacks(w, PuiNuser2Callback);
  1370.     XtRemoveAllCallbacks(w, PuiNuser3Callback);
  1371.     XtRemoveAllCallbacks(w, PuiNuser4Callback);
  1372.     XtRemoveAllCallbacks(w, PuiNsaveCallback);
  1373.     XtRemoveAllCallbacks(w, PuiNcancelCallback);
  1374.     XtRemoveAllCallbacks(w, PuiNhelpCallback);
  1375.     XtRemoveAllCallbacks(w, PuiNjobInfoCallback);
  1376.     XtRemoveAllCallbacks(w, PuiNprinterSelectCallback);
  1377.     XtRemoveAllCallbacks(w, PuiNerrorCallback);
  1378.     XtRemoveAllCallbacks(w, PuiNoptionErrorCallback);
  1379. }
  1380.  
  1381.  
  1382. /**************************************************************************
  1383.  *
  1384.  * Function: ChangeManaged
  1385.  *
  1386.  * Description: Handles the initial geometry determination, dispatches
  1387.  *    error callbacks for initialization errors and selects the initial
  1388.  *    printer.
  1389.  *
  1390.  * Parameters: 
  1391.  *    w (I) - this widget
  1392.  *
  1393.  * Return: none
  1394.  *
  1395.  **************************************************************************/
  1396.  
  1397. static void ChangeManaged(Widget w)
  1398. {
  1399.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)w;
  1400.     PuiPrintBoxPart *pbp = &pb->printBox;
  1401.     int total_width, total_height;
  1402.     DEFARGS(5);
  1403.  
  1404.     /*
  1405.      * Properly center the action area buttons if they have
  1406.      * center placement
  1407.      */
  1408.     if (pbp->res_button_placement == PuiBUTTONS_CENTER) {
  1409.     STARTARGS;
  1410.     SETARG(XmNleftOffset, -WIDTH(pbp->action_rc)/2);
  1411.     XtSetValues(pbp->action_rc, ARGLIST);
  1412.     }
  1413.  
  1414.     /*
  1415.      * Handle calculations and actions that must be done only on widget
  1416.      * realization
  1417.      */
  1418.     if (!XtIsRealized(w)) {
  1419.     /*
  1420.      * If we had an error occurr during initialization we want
  1421.      * to handle it on realization.
  1422.      */
  1423.     if (pbp->init_error_code != 0)
  1424.         HandleError(pb, pbp->init_error_code);
  1425.  
  1426.         /*
  1427.          * Set the width and height of the printer list to encompass
  1428.          * the width of the list items
  1429.          */
  1430.         SetPrinterListSize(pbp);
  1431.  
  1432.         /*
  1433.          * Set the width and height of the option scrolled window to encompass
  1434.          * all options and not show any scrollbars
  1435.          */
  1436.         SetOptionsSize(pbp);
  1437.  
  1438.     /*
  1439.      * Set the width of the action area form
  1440.      */
  1441.     SetActionAreaSize(pbp);
  1442.     }
  1443.  
  1444.     /*
  1445.      * Calculate the required overall widget dimensions based
  1446.      * on the size of the children
  1447.      */
  1448.     CalculateMySize(pb, &total_width, &total_height);
  1449.  
  1450.     /*
  1451.      * Set a size for the overall widget
  1452.      */
  1453.     XtMakeResizeRequest(w, total_width, total_height, NULL, NULL);
  1454.  
  1455.     /*
  1456.      * Position and size all children
  1457.      */
  1458.     DoLayout(pb);
  1459. }
  1460.  
  1461.  
  1462. /**************************************************************************
  1463.  *
  1464.  * Function: GeometryManager
  1465.  *
  1466.  * Description: A yes man for geometry management in our widget.
  1467.  *
  1468.  * Parameters: 
  1469.  *    w (I) - this widget
  1470.  *    request (I) - requested geometry
  1471.  *    reply (O) - allowable geometry
  1472.  *
  1473.  * Return: In our case, always XtGeometryYes.
  1474.  *
  1475.  **************************************************************************/
  1476. /* ARGSUSED */
  1477.  
  1478. static XtGeometryResult GeometryManager(Widget w, XtWidgetGeometry *request,
  1479.                         XtWidgetGeometry *reply)
  1480. {
  1481.     int new_width, new_height;
  1482.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)XtParent(w);
  1483.  
  1484.     /*
  1485.      * If the request concerns size or positioning then do some
  1486.      * processing. For all other requests simply accept the 
  1487.      * request
  1488.      */
  1489.     if (REQUEST_MODE(request, CWX|CWY|CWWidth|CWHeight|CWBorderWidth)) {
  1490.  
  1491.     /*
  1492.      * If query only return yes since we allow any configuration
  1493.      */
  1494.     if (REQUEST_MODE(request, XtCWQueryOnly))
  1495.         return XtGeometryYes;
  1496.  
  1497.     /*
  1498.      * Set the new values
  1499.      */
  1500.     if (REQUEST_MODE(request, CWX))
  1501.         XPOS(w) = request->x;
  1502.     if (REQUEST_MODE(request, CWY))
  1503.         YPOS(w) = request->y;
  1504.     if (REQUEST_MODE(request, CWWidth))
  1505.         WIDTH(w) = request->width;
  1506.     if (REQUEST_MODE(request, CWHeight))
  1507.         HEIGHT(w) = request->height;
  1508.     if (REQUEST_MODE(request, CWBorderWidth))
  1509.         BWIDTH(w) = request->border_width;
  1510.  
  1511.     /*
  1512.      * Calculate a new overall size and attempt to set this size
  1513.      * then relayout the children
  1514.      */
  1515.     CalculateMySize(pb, &new_width, &new_height);
  1516.     if (new_width != WIDTH(pb) || new_height != HEIGHT(pb))
  1517.             XtMakeResizeRequest((Widget)pb, new_width, new_height, NULL, NULL);
  1518.     DoLayout(pb);
  1519.     return XtGeometryYes;
  1520.     }
  1521.  
  1522.     return XtGeometryYes;
  1523. }
  1524.  
  1525.  
  1526. /**************************************************************************
  1527.  *
  1528.  * Function: QueryGeometry
  1529.  *
  1530.  * Description: Responds to a query for widget size changes
  1531.  *
  1532.  * Parameters: 
  1533.  *    w (I) - this widget
  1534.  *    request (I) - proposed new geometry
  1535.  *    reply (O) - our response
  1536.  *
  1537.  * Return: Response to change request
  1538.  *
  1539.  **************************************************************************/
  1540. /* ARGSUSED */
  1541.  
  1542. static XtGeometryResult QueryGeometry(Widget w, XtWidgetGeometry *request,
  1543.                         XtWidgetGeometry *reply)
  1544. {
  1545.     XtGeometryResult result;
  1546.  
  1547.     request->request_mode &= CWWidth | CWHeight;
  1548.  
  1549.     /*
  1550.      * Parent isn't going to change width or height so agree
  1551.      */
  1552.     if (request->request_mode == 0)
  1553.     return XtGeometryYes;
  1554.  
  1555.     /*
  1556.      * Clear reply request mode
  1557.      */
  1558.     reply->request_mode = 0;
  1559.  
  1560.     /*
  1561.      * If proposed size is large enough, accept it. Otherwise,
  1562.      * suggest an arbitrary minimum size
  1563.      */
  1564.     if (request->request_mode & CWHeight) {
  1565.     if (request->height < 5) {
  1566.         result = XtGeometryAlmost;
  1567.         reply->height = 5;
  1568.         reply->request_mode |= CWHeight;
  1569.     } else
  1570.         result = XtGeometryYes;
  1571.     }
  1572.  
  1573.     if (request->request_mode & CWWidth) {
  1574.     if (request->width < 5) {
  1575.         result = XtGeometryAlmost;
  1576.         reply->width = 5;
  1577.         reply->request_mode |= CWWidth;
  1578.     } else
  1579.         result = XtGeometryYes;
  1580.     }
  1581.  
  1582.     return result;
  1583. }
  1584.  
  1585.  
  1586. /**************************************************************************
  1587.  *
  1588.  * Function: Resize
  1589.  *
  1590.  * Description: Handles the resizing of the widget
  1591.  *
  1592.  * Parameters: 
  1593.  *    w (I) - this widget
  1594.  *
  1595.  * Return: none
  1596.  *
  1597.  **************************************************************************/
  1598.  
  1599. static void Resize(Widget w)
  1600. {
  1601.     /*
  1602.      * Call our superclass's resize routine to do whatever it
  1603.      * needs to do (e.g. handle redrawing of shadows).
  1604.      */
  1605.     (*((XmBulletinBoardWidgetClass)xmBulletinBoardWidgetClass)
  1606.                                 ->core_class.resize)(w);
  1607.  
  1608.     DoLayout((PuiPrintBoxWidget)w);
  1609. }
  1610.  
  1611.  
  1612. /**************************************************************************
  1613.  *
  1614.  * Function: InsertChild
  1615.  *
  1616.  * Description: Handles the insertion of a user defined work area. Only
  1617.  *    one work area child is allowed.
  1618.  *
  1619.  * Parameters: 
  1620.  *    child (I) - child widget to be inserted
  1621.  *
  1622.  * Return: none
  1623.  *
  1624.  **************************************************************************/
  1625.  
  1626. static void InsertChild(Widget child)
  1627. {
  1628.     PuiPrintBoxWidget pb;
  1629.  
  1630.     /*
  1631.      * Get a pointer to our class part. The child parent is, by definition
  1632.      * our widget.
  1633.      */
  1634.     pb = (PuiPrintBoxWidget)XtParent(child);
  1635.  
  1636.     /*
  1637.      * If we are adding our own internal widgets then pass thru. Otherwise
  1638.      * check if we already have a work area and is so issue a warning
  1639.      */
  1640.     if (!pb->printBox.adding_pb_widgets) {
  1641.     if (pb->printBox.work_area)
  1642.         XtError(gettxt(_SGI_LIBPRINTUI_ONE_CHILD,
  1643.         "PuiPrintBox - only one work area child widget allowed"));
  1644.     pb->printBox.work_area = child;
  1645.     }
  1646.  
  1647.     /*
  1648.      * Call our superclass's insert_child routine to do the 
  1649.      * dirty work of inserting the child in the proper data
  1650.      * structures
  1651.      */
  1652.     (*((XmBulletinBoardWidgetClass)xmBulletinBoardWidgetClass)
  1653.                 ->composite_class.insert_child)(child);
  1654. }
  1655.  
  1656.  
  1657. /**************************************************************************
  1658.  *
  1659.  * Function: DeleteChild
  1660.  *
  1661.  * Description: Handles the deletion of a user defined work area.
  1662.  *
  1663.  * Parameters: 
  1664.  *    child (I) - child widget to be deleted
  1665.  *
  1666.  * Return: none
  1667.  *
  1668.  **************************************************************************/
  1669.  
  1670. static void DeleteChild(Widget child)
  1671. {
  1672.     PuiPrintBoxWidget pb;
  1673.     PuiPrintBoxPart *pbp;
  1674.  
  1675.     /*
  1676.      * Get a pointer to our class part. The child parent is, by definition
  1677.      * our widget.
  1678.      */
  1679.     pb = (PuiPrintBoxWidget)XtParent(child);
  1680.     pbp = &pb->printBox;
  1681.  
  1682.     /*
  1683.      * NULL out the proper widget variable
  1684.      */
  1685.     if (child == pbp->work_area)
  1686.         pbp->work_area = NULL;
  1687.     else if (child == pbp->separator)
  1688.     pbp->separator = NULL;
  1689.  
  1690.     /*
  1691.      * Call our superclass's delete_child routine to do the 
  1692.      * dirty work of deleting the child in the proper data
  1693.      * structures
  1694.      */
  1695.     (*((XmBulletinBoardWidgetClass)xmBulletinBoardWidgetClass)
  1696.                 ->composite_class.delete_child)(child);
  1697. }
  1698.  
  1699.  
  1700. /**************************************************************************
  1701.  *
  1702.  * Function: SetValues
  1703.  *
  1704.  * Description: Handles the setting of resource values by the XtSetValues
  1705.  *    Xt function.
  1706.  *
  1707.  * Parameters: 
  1708.  *    cur (I) - current settings of widget variables
  1709.  *    req (I) - requested values of widget variables not processed
  1710.  *        by superclass.
  1711.  *    new (I) - new widget values already processed by superclass
  1712.  *    args (I) - arguments to SetValues function
  1713.  *    num_args (I) - number of arguments in args
  1714.  *
  1715.  * Return: True if XClearArea is to be called and expose event generated,
  1716.  *    Flase if no redisplay required.
  1717.  *
  1718.  **************************************************************************/
  1719. /* ARGSUSED */
  1720.  
  1721. static Boolean SetValues(Widget cur, Widget req, Widget new,
  1722.                 ArgList args, Cardinal *num_args)
  1723. {
  1724.     PuiPrintBoxWidget cpb = (PuiPrintBoxWidget) cur;
  1725.     PuiPrintBoxPart *cpbp = &cpb->printBox;
  1726.     PuiPrintBoxWidget npb = (PuiPrintBoxWidget) new;
  1727.     PuiPrintBoxPart *npbp = &npb->printBox;
  1728.     PuiPrintBoxWidget rpb = (PuiPrintBoxWidget) req;
  1729.     PuiPrintBoxPart *rpbp = &rpb->printBox;
  1730.  
  1731.     /*
  1732.      * PRINTER LIST INFO
  1733.      */
  1734.  
  1735.     /* List of printers available */
  1736.     if (cpbp->res_printer_list != npbp->res_printer_list) {
  1737.     npbp->res_printer_list = cpbp->res_printer_list;
  1738.     XtWarning(gettxt(_SGI_LIBPRINTUI_PLIST_RO,
  1739.         "PuiPrintBox - cannot change printerList (read-only)"));
  1740.     }
  1741.  
  1742.     /* Number of printers available */
  1743.     if (cpbp->res_num_printers != npbp->res_num_printers) {
  1744.     npbp->res_num_printers = cpbp->res_num_printers;
  1745.     XtWarning(gettxt(_SGI_LIBPRINTUI_NUMP_RO,
  1746.         "PuiPrintBox - cannot change numPrinters (read-only)"));
  1747.     }
  1748.  
  1749.     /* Default printer */
  1750.     if (cpbp->res_default_printer != npbp->res_default_printer) {
  1751.     npbp->res_default_printer = cpbp->res_default_printer;
  1752.     XtWarning(gettxt(_SGI_LIBPRINTUI_DEFP_RO,
  1753.         "PuiPrintBox - cannot change defPrinter (read-only)"));
  1754.     }
  1755.  
  1756.     /*
  1757.      * BASIC INFO
  1758.      */
  1759.  
  1760.     /* Job Type */
  1761.     if (cpbp->res_job_type != npbp->res_job_type) {
  1762.     npbp->res_job_type = cpbp->res_job_type;
  1763.     XtWarning(gettxt(_SGI_LIBPRINTUI_JOBTYPE,
  1764.         "PuiPrintBox - cannot change jobType after creation"));
  1765.     }
  1766.  
  1767.     /* Filename */
  1768.     if (cpbp->res_filename != npbp->res_filename) {
  1769.         SetFilenames(npbp);
  1770.     SetStringValue(&cpbp->res_filename, &rpbp->res_filename,
  1771.                         &npbp->res_filename);
  1772.     }
  1773.  
  1774.     /* Filename field display */
  1775.     if (cpbp->res_show_fname != npbp->res_show_fname) {
  1776.     npbp->res_show_fname = cpbp->res_show_fname;
  1777.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWFNAME,
  1778.         "PuiPrintBox - cannot change showFilename after creation"));
  1779.     }
  1780.  
  1781.     /* Options display */
  1782.     if (cpbp->res_show_opts != npbp->res_show_opts) {
  1783.     npbp->res_show_opts = cpbp->res_show_opts;
  1784.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWOPT,
  1785.         "PuiPrintBox - cannot change showOptions after creation"));
  1786.     }
  1787.  
  1788.     /* Number of copies option display */
  1789.     if (cpbp->res_show_numcopies != npbp->res_show_numcopies) {
  1790.     npbp->res_show_numcopies = cpbp->res_show_numcopies;
  1791.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWNUMCOPIES,
  1792.         "PuiPrintBox - cannot change showNumCopies after creation"));
  1793.     }
  1794.  
  1795.     /* Banner page title option display */
  1796.     if (cpbp->res_show_bannertitle != npbp->res_show_bannertitle) {
  1797.     npbp->res_show_bannertitle = cpbp->res_show_bannertitle;
  1798.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWBANNERTITLE,
  1799.         "PuiPrintBox - cannot change showBannerTitle after creation"));
  1800.     }
  1801.  
  1802.     /* Job completion notification option display */
  1803.     if (cpbp->res_show_completion != npbp->res_show_completion) {
  1804.     npbp->res_show_completion = cpbp->res_show_completion;
  1805.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWCOMPLETION,
  1806.         "PuiPrintBox - cannot change showCompletion after creation"));
  1807.     }
  1808.  
  1809.     /* Print job handling option display */
  1810.     if (cpbp->res_show_handling != npbp->res_show_handling) {
  1811.     npbp->res_show_handling = cpbp->res_show_handling;
  1812.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWHANDLING,
  1813.         "PuiPrintBox - cannot change showHandling after creation"));
  1814.     }
  1815.  
  1816.     /* Printer specific options display */
  1817.     if (cpbp->res_show_printeroptions != npbp->res_show_printeroptions) {
  1818.     npbp->res_show_printeroptions = cpbp->res_show_printeroptions;
  1819.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWPRINTEROPTIONS,
  1820.         "PuiPrintBox - cannot change showPrinterOptions after creation"));
  1821.     }
  1822.  
  1823.     /* Options button display */
  1824.     if (cpbp->res_show_optionsbutton != npbp->res_show_optionsbutton) {
  1825.     npbp->res_show_optionsbutton = cpbp->res_show_optionsbutton;
  1826.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWOPTIONSBUTTON,
  1827.         "PuiPrintBox - cannot change showOptionsButton after creation"));
  1828.     }
  1829.  
  1830.     /* Save button display */
  1831.     if (cpbp->res_show_savebutton != npbp->res_show_savebutton) {
  1832.     npbp->res_show_savebutton = cpbp->res_show_savebutton;
  1833.     XtWarning(gettxt(_SGI_LIBPRINTUI_SHOWSAVEBUTTON,
  1834.         "PuiPrintBox - cannot change showSaveButton after creation"));
  1835.     }
  1836.  
  1837.     /* Action area button placement */
  1838.     if (cpbp->res_button_placement != npbp->res_button_placement) {
  1839.     npbp->res_button_placement = cpbp->res_button_placement;
  1840.     XtWarning(gettxt(_SGI_LIBPRINTUI_BPLACE,
  1841.         "PuiPrintBox - cannot change buttonPlacement after creation"));
  1842.     }
  1843.  
  1844.     /* Action area button spacing */
  1845.     if (cpbp->res_button_spacing != npbp->res_button_spacing) {
  1846.     npbp->res_button_spacing = cpbp->res_button_spacing;
  1847.     XtWarning(gettxt(_SGI_LIBPRINTUI_BSPACE,
  1848.         "PuiPrintBox - cannot change buttonSpacing after creation"));
  1849.     }
  1850.  
  1851.     /* Printer list visible item count */
  1852.     if (cpbp->res_vis_count != npbp->res_vis_count) {
  1853.     npbp->res_vis_count = cpbp->res_vis_count;
  1854.     XtWarning(gettxt(_SGI_LIBPRINTUI_VISCOUNT,
  1855.         "PuiPrintBox - cannot change listVisibleItemCount after creation"));
  1856.     }
  1857.  
  1858.     /* Printer */
  1859.     if (cpbp->res_printer != npbp->res_printer) {
  1860.     if (!npbp->res_printer) {
  1861.         npbp->res_printer = cpbp->res_printer;
  1862.         XtWarning(gettxt(_SGI_LIBPRINTUI_PNAME,
  1863.             "PuiPrintBox - printer name cannot be NULL"));
  1864.     } else {
  1865.         npbp->selected_printer_index = FindPrinter(npbp, npbp->res_printer);
  1866.         if (XtIsManaged(new))
  1867.            SetPrinter(npbp);
  1868.         SetStringValue(&cpbp->res_printer, &rpbp->res_printer,
  1869.                         &npbp->res_printer);
  1870.         }
  1871.     }
  1872.  
  1873.     /*
  1874.      * TEXT FIELD SENSITIVITY
  1875.      */
  1876.  
  1877.     /* Insensitive foreground color */
  1878.     if (cpbp->tfield_insensitive.foreground !=
  1879.                     npbp->tfield_insensitive.foreground) {
  1880.         SetTextFieldSensitivity(npbp, npbp->files_widget,
  1881.                         npbp->res_filename_sensitive);
  1882.         SetTextFieldSensitivity(npbp, npbp->numcopies_text_widget,
  1883.                         npbp->res_numcopies_sensitive);
  1884.         SetTextFieldSensitivity(npbp, npbp->spec_options_widget,
  1885.                         npbp->res_poptions_sensitive);
  1886.     }
  1887.  
  1888.     /* Insensitive background color */
  1889.     if (cpbp->tfield_insensitive.background !=
  1890.                     npbp->tfield_insensitive.background) {
  1891.         SetTextFieldSensitivity(npbp, npbp->files_widget,
  1892.                         npbp->res_filename_sensitive);
  1893.         SetTextFieldSensitivity(npbp, npbp->numcopies_text_widget,
  1894.                         npbp->res_numcopies_sensitive);
  1895.         SetTextFieldSensitivity(npbp, npbp->spec_options_widget,
  1896.                         npbp->res_poptions_sensitive);
  1897.     }
  1898.  
  1899.     /* Filename field sensitivity */
  1900.     if (cpbp->res_filename_sensitive != npbp->res_filename_sensitive)
  1901.         SetTextFieldSensitivity(npbp, npbp->files_widget,
  1902.                         npbp->res_filename_sensitive);
  1903.     /* Number of copies field sensitivity */
  1904.     if (cpbp->res_numcopies_sensitive != npbp->res_numcopies_sensitive)
  1905.         SetTextFieldSensitivity(npbp, npbp->numcopies_text_widget,
  1906.                         npbp->res_numcopies_sensitive);
  1907.     /* Print options field sensitivity */
  1908.     if (cpbp->res_poptions_sensitive != npbp->res_poptions_sensitive)
  1909.         SetTextFieldSensitivity(npbp, npbp->spec_options_widget,
  1910.                         npbp->res_poptions_sensitive);
  1911.  
  1912.     /*
  1913.      * FONTS
  1914.      */
  1915.     if (cpbp->res_printer_font != npbp->res_printer_font) {
  1916.     npbp->res_printer_font = cpbp->res_printer_font;
  1917.     XtWarning(gettxt(_SGI_LIBPRINTUI_PFONT,
  1918.         "PuiPrintBox - cannot change printerFont after creation"));
  1919.     }
  1920.  
  1921.     if (cpbp->res_def_printer_font != npbp->res_def_printer_font) {
  1922.     npbp->res_def_printer_font = cpbp->res_def_printer_font;
  1923.     XtWarning(gettxt(_SGI_LIBPRINTUI_DEFPFONT,
  1924.         "PuiPrintBox - cannot change defaultPrinterFont after creation"));
  1925.     }
  1926.  
  1927.     /*
  1928.      * LABELS
  1929.      */
  1930.     if (cpbp->res_printb_label != npbp->res_printb_label)
  1931.     UpdateLabel(npbp->printb_widget, XmNlabelString,
  1932.                     &npbp->res_printb_label);
  1933.  
  1934.     if (cpbp->res_user1b_label != npbp->res_user1b_label)
  1935.     UpdateLabel(npbp->user1b_widget, XmNlabelString,
  1936.                     &npbp->res_user1b_label);
  1937.  
  1938.     if (cpbp->res_user2b_label != npbp->res_user2b_label)
  1939.     UpdateLabel(npbp->user2b_widget, XmNlabelString,
  1940.                     &npbp->res_user2b_label);
  1941.  
  1942.     if (cpbp->res_user3b_label != npbp->res_user3b_label)
  1943.     UpdateLabel(npbp->user3b_widget, XmNlabelString,
  1944.                     &npbp->res_user3b_label);
  1945.  
  1946.     if (cpbp->res_user4b_label != npbp->res_user4b_label)
  1947.     UpdateLabel(npbp->user4b_widget, XmNlabelString,
  1948.                     &npbp->res_user4b_label);
  1949.  
  1950.     if (cpbp->res_optionsb_label != npbp->res_optionsb_label)
  1951.     UpdateLabel(npbp->optionsb_widget, XmNlabelString,
  1952.                     &npbp->res_optionsb_label);
  1953.  
  1954.     if (cpbp->res_saveb_label != npbp->res_saveb_label)
  1955.     UpdateLabel(npbp->saveb_widget, XmNlabelString,
  1956.                     &npbp->res_saveb_label);
  1957.  
  1958.     if (cpbp->res_cancelb_label != npbp->res_cancelb_label)
  1959.     UpdateLabel(npbp->cancelb_widget, XmNlabelString,
  1960.                     &npbp->res_cancelb_label);
  1961.  
  1962.     if (cpbp->res_helpb_label != npbp->res_helpb_label)
  1963.     UpdateLabel(npbp->helpb_widget, XmNlabelString,
  1964.                     &npbp->res_helpb_label);
  1965.  
  1966.     if (cpbp->res_files_label != npbp->res_files_label)
  1967.     UpdateLabel(npbp->files_label_widget, XmNlabelString,
  1968.                     &npbp->res_files_label);
  1969.  
  1970.     if (cpbp->res_plist_label != npbp->res_plist_label)
  1971.     UpdateLabel(npbp->plist_label_widget, XmNlabelString,
  1972.                     &npbp->res_plist_label);
  1973.  
  1974.     if (cpbp->res_opts_label != npbp->res_opts_label)
  1975.     UpdateLabel(npbp->opts_label_widget, XmNlabelString,
  1976.                     &npbp->res_opts_label);
  1977.  
  1978.     if (cpbp->res_numcopies_label != npbp->res_numcopies_label)
  1979.     UpdateLabel(npbp->numcopies_label_widget, XmNlabelString,
  1980.                     &npbp->res_numcopies_label);
  1981.  
  1982.     if (cpbp->res_title_label != npbp->res_title_label)
  1983.     UpdateLabel(npbp->title_label_widget, XmNlabelString,
  1984.                     &npbp->res_title_label);
  1985.  
  1986.     if (cpbp->res_deftitle_label != npbp->res_deftitle_label)
  1987.     UpdateLabel(npbp->banner_deftitle_widget, XmNlabelString,
  1988.                     &npbp->res_deftitle_label);
  1989.  
  1990.     if (cpbp->res_spectitle_label != npbp->res_spectitle_label)
  1991.     UpdateLabel(npbp->banner_spectitle_widget, XmNlabelString,
  1992.                     &npbp->res_spectitle_label);
  1993.  
  1994.     if (cpbp->res_complete_label != npbp->res_complete_label)
  1995.     UpdateLabel(npbp->complete_label_widget, XmNlabelString,
  1996.                     &npbp->res_complete_label);
  1997.  
  1998.     if (cpbp->res_complete_mail_label != npbp->res_complete_mail_label)
  1999.     UpdateLabel(npbp->complete_mail_widget, XmNlabelString,
  2000.                     &npbp->res_complete_mail_label);
  2001.  
  2002.     if (cpbp->res_complete_mess_label != npbp->res_complete_mess_label)
  2003.     UpdateLabel(npbp->complete_mess_widget, XmNlabelString,
  2004.                     &npbp->res_complete_mess_label);
  2005.  
  2006.     if (cpbp->res_handling_label != npbp->res_handling_label)
  2007.     UpdateLabel(npbp->handling_label_widget, XmNlabelString,
  2008.                     &npbp->res_handling_label);
  2009.  
  2010.     if (cpbp->res_handling_copy_label != npbp->res_handling_copy_label)
  2011.     UpdateLabel(npbp->handling_copy_widget, XmNlabelString,
  2012.                     &npbp->res_handling_copy_label);
  2013.  
  2014.     if (cpbp->res_handling_link_label != npbp->res_handling_link_label)
  2015.     UpdateLabel(npbp->handling_link_widget, XmNlabelString,
  2016.                     &npbp->res_handling_link_label);
  2017.  
  2018.     if (cpbp->res_spec_options_label != npbp->res_spec_options_label)
  2019.     UpdateLabel(npbp->spec_options_label_widget, XmNlabelString,
  2020.                     &npbp->res_spec_options_label);
  2021.  
  2022.  
  2023.     if (cpbp->res_savedlg_title_label != npbp->res_savedlg_title_label)
  2024.     UpdateLabel(npbp->save_dialog_widget, XmNdialogTitle,
  2025.                     &npbp->res_savedlg_title_label);
  2026.  
  2027.     if (strcmp(npbp->user_name, "root") && strcmp(npbp->user_name, "lp")) {
  2028.         if (cpbp->res_savedlg_saveb_label != npbp->res_savedlg_saveb_label)
  2029.         UpdateLabel(npbp->save_dialog_widget, XmNokLabelString,
  2030.                     &npbp->res_savedlg_saveb_label);
  2031.     } else {
  2032.         if (cpbp->res_savedlg_userb_label != npbp->res_savedlg_userb_label)
  2033.         UpdateLabel(npbp->save_dialog_widget, XmNokLabelString,
  2034.                     &npbp->res_savedlg_userb_label);
  2035.     }
  2036.  
  2037.     if (cpbp->res_savedlg_allb_label != npbp->res_savedlg_allb_label)
  2038.         UpdateLabel(npbp->save_dialog_widget, XmNcancelLabelString,
  2039.                     &npbp->res_savedlg_allb_label);
  2040.  
  2041.     if (cpbp->res_savedlg_cancelb_label != npbp->res_savedlg_cancelb_label)
  2042.     UpdateLabel(npbp->save_dialog_widget, XmNhelpLabelString,
  2043.                     &npbp->res_savedlg_cancelb_label);
  2044.  
  2045.     if (cpbp->res_savedlg_msg_label != npbp->res_savedlg_msg_label)
  2046.     UpdateLabel(npbp->save_msg_widget, XmNlabelString,
  2047.                     &npbp->res_savedlg_msg_label);
  2048.  
  2049.     /*
  2050.      * OPTIONS
  2051.      */
  2052.  
  2053.     /* Number of copies */
  2054.     if (cpbp->res_numcopies != npbp->res_numcopies)
  2055.     SetOptionNumCopies(npbp);
  2056.  
  2057.     /* Banner page */
  2058.     if (cpbp->res_job_title != npbp->res_job_title) {
  2059.     SetOptionBanner(npbp);
  2060.     SetStringValue(&cpbp->res_job_title, &rpbp->res_job_title,
  2061.                         &npbp->res_job_title);
  2062.     }
  2063.  
  2064.     /* Copy file */
  2065.     if (cpbp->res_copy != npbp->res_copy)
  2066.     SetOptionJobHandling(npbp);
  2067.  
  2068.     /* Mail and Message */
  2069.     if (cpbp->res_mail != npbp->res_mail ||
  2070.         cpbp->res_message != npbp->res_message)
  2071.     SetOptionCompletion(npbp);
  2072.  
  2073.     /* Printer specific options */
  2074.     if (cpbp->res_spec_opts != npbp->res_spec_opts) {
  2075.     SetOptionPrinterSpecific(npbp);
  2076.     SetStringValue(&cpbp->res_spec_opts, &rpbp->res_spec_opts,
  2077.                         &npbp->res_spec_opts);
  2078.         if (npbp->selected_printer_index >= 0)
  2079.             UpdatePrinterOption(npb,
  2080.             &npbp->printer_options[npbp->selected_printer_index]);
  2081.     }
  2082.  
  2083.     return False;
  2084. }
  2085.  
  2086.  
  2087. /*
  2088.  ==========================================================================
  2089.             PRIVATE WIDGET METHODS
  2090.  ==========================================================================
  2091. */
  2092.  
  2093.  
  2094. /**************************************************************************
  2095.  *
  2096.  * Function: CreateActionArea
  2097.  *
  2098.  * Description: Creates the action area widgets. The action area is the
  2099.  *    area at the bottom of the box that contains the 'Print', 'Help',
  2100.  *    etc. buttons.
  2101.  *
  2102.  * Parameters: 
  2103.  *    pb (I) - this widget
  2104.  *
  2105.  * Return: none
  2106.  *
  2107.  **************************************************************************/
  2108.  
  2109. static void CreateActionArea(PuiPrintBoxWidget pb)
  2110. {
  2111.     PuiPrintBoxPart *pbp = &pb->printBox;
  2112.     DEFARGS(15);
  2113.  
  2114.     /*
  2115.      * Create the separator
  2116.      */
  2117.     pbp->separator = XtCreateManagedWidget("actionSeparator",
  2118.                     xmSeparatorWidgetClass,
  2119.                     (Widget)pb, NULL, 0);
  2120.  
  2121.     /*
  2122.      * Create a form so that we can adhere the buttons to the right
  2123.      * end of it
  2124.      */
  2125.     STARTARGS;
  2126.     SETARG(XmNskipAdjust, True);
  2127.     pbp->action_form = XtCreateManagedWidget("actionForm", xmFormWidgetClass,
  2128.                     (Widget)pb, ARGLIST);
  2129.  
  2130.     /*
  2131.      * Create a RowColumn to actually hold the buttons
  2132.      */
  2133.     STARTARGS;
  2134.     SETARG(XmNorientation, XmHORIZONTAL);
  2135.     SETARG(XmNpacking, XmPACK_COLUMN);
  2136.     SETARG(XmNentryAlignment, XmALIGNMENT_CENTER);
  2137.     SETARG(XmNmarginHeight, 0);
  2138.     SETARG(XmNmarginWidth, 0);
  2139.     SETARG(XmNspacing, pbp->res_button_spacing);
  2140.     SETARG(XmNtopAttachment, XmATTACH_FORM);
  2141.     SETARG(XmNbottomAttachment, XmATTACH_FORM);
  2142.     if (pbp->res_button_placement == PuiBUTTONS_LEFT) {
  2143.         SETARG(XmNleftAttachment, XmATTACH_FORM);
  2144.     } else if (pbp->res_button_placement == PuiBUTTONS_RIGHT) {
  2145.         SETARG(XmNrightAttachment, XmATTACH_FORM);
  2146.     } else {
  2147.         SETARG(XmNleftAttachment, XmATTACH_POSITION);
  2148.         SETARG(XmNleftPosition, 50);
  2149.     }
  2150.     pbp->action_rc = XtCreateManagedWidget("actionRowC",
  2151.                     xmRowColumnWidgetClass,
  2152.                     pbp->action_form, ARGLIST);
  2153.  
  2154.     /*
  2155.      * Create the action area buttons
  2156.      */
  2157.  
  2158.     /*        Print button */
  2159.     STARTARGS;
  2160.     SETARG(XmNlabelString, pbp->res_printb_label);
  2161.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_PRINT_BUTTON);
  2162.     pbp->printb_widget = XtCreateManagedWidget(DEF_PRINTB_LABEL,
  2163.                 xmPushButtonWidgetClass,
  2164.                 pbp->action_rc, ARGLIST);
  2165.  
  2166.     /*        User buttons 1-4. Must be explicitly managed by app. */
  2167.     STARTARGS;
  2168.     SETARG(XmNlabelString, pbp->res_user1b_label);
  2169.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_USER1_BUTTON);
  2170.     pbp->user1b_widget = XtCreateWidget(DEF_USER1B_LABEL,
  2171.                 xmPushButtonWidgetClass,
  2172.                 pbp->action_rc, ARGLIST);
  2173.     STARTARGS;
  2174.     SETARG(XmNlabelString, pbp->res_user2b_label);
  2175.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_USER2_BUTTON);
  2176.     pbp->user2b_widget = XtCreateWidget(DEF_USER2B_LABEL,
  2177.                 xmPushButtonWidgetClass,
  2178.                 pbp->action_rc, ARGLIST);
  2179.     STARTARGS;
  2180.     SETARG(XmNlabelString, pbp->res_user3b_label);
  2181.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_USER3_BUTTON);
  2182.     pbp->user3b_widget = XtCreateWidget(DEF_USER3B_LABEL,
  2183.                 xmPushButtonWidgetClass,
  2184.                 pbp->action_rc, ARGLIST);
  2185.     STARTARGS;
  2186.     SETARG(XmNlabelString, pbp->res_user4b_label);
  2187.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_USER4_BUTTON);
  2188.     pbp->user4b_widget = XtCreateWidget(DEF_USER4B_LABEL,
  2189.                 xmPushButtonWidgetClass,
  2190.                 pbp->action_rc, ARGLIST);
  2191.  
  2192.     /*        Options button */
  2193.     STARTARGS;
  2194.     SETARG(XmNlabelString, pbp->res_optionsb_label);
  2195.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_OPTIONS_BUTTON);
  2196.     pbp->optionsb_widget = XtCreateWidget(DEF_OPTIONSB_LABEL,
  2197.                 xmPushButtonWidgetClass,
  2198.                 pbp->action_rc, ARGLIST);
  2199.     if (pbp->res_show_optionsbutton) {
  2200.     XtManageChild(pbp->optionsb_widget);
  2201.         XtSetSensitive(pbp->optionsb_widget, False);
  2202.     }
  2203.  
  2204.     /*        Save button */
  2205.     STARTARGS;
  2206.     SETARG(XmNlabelString, pbp->res_saveb_label);
  2207.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_SAVE_BUTTON);
  2208.     pbp->saveb_widget = XtCreateWidget(DEF_SAVEB_LABEL,
  2209.                 xmPushButtonWidgetClass,
  2210.                 pbp->action_rc, ARGLIST);
  2211.     if (pbp->res_show_savebutton)
  2212.     XtManageChild(pbp->saveb_widget);
  2213.  
  2214.     /*        Cancel button. Set as BB's cancel button */
  2215.     STARTARGS;
  2216.     SETARG(XmNlabelString, pbp->res_cancelb_label);
  2217.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_CANCEL_BUTTON);
  2218.     pb->bulletin_board.cancel_button = pbp->cancelb_widget =
  2219.         XtCreateManagedWidget(DEF_CANCELB_LABEL,
  2220.                 xmPushButtonWidgetClass,
  2221.                 pbp->action_rc, ARGLIST);
  2222.  
  2223.     /*        Help button */
  2224.     STARTARGS;
  2225.     SETARG(XmNlabelString, pbp->res_helpb_label);
  2226.     SETARG(XmNuserData, (XtPointer)PuiPRINTBOX_HELP_BUTTON);
  2227.     pbp->helpb_widget = XtCreateManagedWidget(DEF_HELPB_LABEL,
  2228.                 xmPushButtonWidgetClass,
  2229.                 pbp->action_rc, ARGLIST);
  2230.  
  2231.     /*
  2232.      * Register the action area button callbacks
  2233.      */
  2234.     XtAddCallback(pbp->printb_widget, XmNactivateCallback, ActionAreaCB,
  2235.                     (XtPointer)pb);
  2236.     XtAddCallback(pbp->user1b_widget, XmNactivateCallback, ActionAreaCB,
  2237.                     (XtPointer)pb);
  2238.     XtAddCallback(pbp->user2b_widget, XmNactivateCallback, ActionAreaCB,
  2239.                     (XtPointer)pb);
  2240.     XtAddCallback(pbp->user3b_widget, XmNactivateCallback, ActionAreaCB,
  2241.                     (XtPointer)pb);
  2242.     XtAddCallback(pbp->user4b_widget, XmNactivateCallback, ActionAreaCB,
  2243.                     (XtPointer)pb);
  2244.     XtAddCallback(pbp->saveb_widget, XmNactivateCallback, QueryForSaveCB,
  2245.                     (XtPointer)pb);
  2246.     XtAddCallback(pbp->cancelb_widget, XmNactivateCallback, ActionAreaCB,
  2247.                     (XtPointer)pb);
  2248.     XtAddCallback(pbp->helpb_widget, XmNactivateCallback, ActionAreaCB,
  2249.                     (XtPointer)pb);
  2250.  
  2251.     /*
  2252.      * Register the option button callback
  2253.      */
  2254.     XtAddCallback(pbp->optionsb_widget, XmNactivateCallback, OptionButtonCB,
  2255.                     (XtPointer)pb);
  2256.  
  2257.     /*
  2258.      * Register the default print callback
  2259.      */
  2260.     XtAddCallback(pbp->printb_widget, XmNactivateCallback,
  2261.                     SubmitPrintJobCB, (XtPointer)pb);
  2262.  
  2263.     /*
  2264.      * If parent is a dialog shell and BB's autoUnmanage resource it true
  2265.      * register the unamange callback
  2266.      */
  2267.     if (XmIsDialogShell(XtParent(pb)) && pb->bulletin_board.auto_unmanage) {
  2268.         XtAddCallback(pbp->printb_widget, XmNactivateCallback,
  2269.                 UnmanageCB, (XtPointer)pb);
  2270.         XtAddCallback(pbp->cancelb_widget, XmNactivateCallback,
  2271.                 UnmanageCB, (XtPointer)pb);
  2272.     }
  2273. }
  2274.  
  2275.  
  2276. /**************************************************************************
  2277.  *
  2278.  * Function: CreateControlArea
  2279.  *
  2280.  * Description: Creates the control area widgets. The control area is the
  2281.  *    area where printers are selected and job printing options are set.
  2282.  *
  2283.  * Parameters: 
  2284.  *    pb (I) - this widget
  2285.  *
  2286.  * Return: none
  2287.  *
  2288.  **************************************************************************/
  2289.  
  2290. static void CreateControlArea(PuiPrintBoxWidget pb)
  2291. {
  2292.     PuiPrintBoxPart *pbp = &pb->printBox;
  2293.     XmFontList flist, nlist;
  2294.     XmFontListEntry printer_entry, defprinter_entry;
  2295.     DEFARGS(15);
  2296.     Widget wlist[2], clip;
  2297.     Pixel bg;
  2298.  
  2299.     /*
  2300.      * Create the file and printer selection section
  2301.      */
  2302.     pbp->pf_form = XtCreateManagedWidget("printerFileForm",
  2303.                     xmFormWidgetClass,
  2304.                     (Widget)pb, NULL, 0);
  2305.  
  2306.     /*
  2307.      * Filename selection section
  2308.      */
  2309.     STARTARGS;
  2310.     SETARG(XmNlabelString, pbp->res_files_label);
  2311.     SETARG(XmNtopAttachment, XmATTACH_FORM);
  2312.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2313.     wlist[0] = pbp->files_label_widget = XtCreateWidget(DEF_FILES_LABEL,
  2314.                     xmLabelWidgetClass,
  2315.                     pbp->pf_form, ARGLIST);
  2316.     STARTARGS;
  2317.     SETARG(XmNtopAttachment, XmATTACH_WIDGET);
  2318.     SETARG(XmNtopWidget, pbp->files_label_widget);
  2319.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2320.     SETARG(XmNrightAttachment, XmATTACH_FORM);
  2321.     wlist[1] = pbp->files_widget = XtCreateWidget("fileText",
  2322.                     xmTextFieldWidgetClass,
  2323.                     pbp->pf_form, ARGLIST);
  2324.     if (pbp->res_job_type == PuiPRINTJOB_FILENAME && pbp->res_show_fname)
  2325.     XtManageChildren(wlist, 2);
  2326.  
  2327.     /*
  2328.      * Register the sensitivity check on filename entry
  2329.      */
  2330.     XtAddCallback(pbp->files_widget, XmNvalueChangedCallback,
  2331.                     PrintSensitiveCB, (XtPointer)pbp);
  2332.  
  2333.     /*
  2334.      * Register character verify check on filename entry
  2335.      */
  2336.     XtAddCallback(pbp->files_widget, XmNmodifyVerifyCallback,
  2337.             _PuiCharacterVerifyCB, (XtPointer)TYPEIN_BAD_CHARS);
  2338.  
  2339.     /*
  2340.      * Printer selection section
  2341.      */
  2342.     STARTARGS;
  2343.     if (pbp->res_job_type == PuiPRINTJOB_FILENAME && pbp->res_show_fname) {
  2344.         SETARG(XmNtopAttachment, XmATTACH_WIDGET);
  2345.         SETARG(XmNtopWidget, pbp->files_widget);
  2346.         SETARG(XmNtopOffset, MARGIN_HEIGHT(pb) - 4);
  2347.     } else {
  2348.         SETARG(XmNtopAttachment, XmATTACH_FORM);
  2349.     }
  2350.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2351.     SETARG(XmNlabelString, pbp->res_plist_label);
  2352.     SETARG(XmNalignment, XmALIGNMENT_BEGINNING);
  2353.     pbp->plist_label_widget = XtCreateManagedWidget(DEF_PLIST_LABEL,
  2354.                     xmLabelWidgetClass,
  2355.                     pbp->pf_form, ARGLIST);
  2356.     STARTARGS;
  2357.     SETARG(XmNtopAttachment, XmATTACH_WIDGET);
  2358.     SETARG(XmNtopWidget, pbp->plist_label_widget);
  2359.     SETARG(XmNbottomAttachment, XmATTACH_FORM);
  2360.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2361.     SETARG(XmNrightAttachment, XmATTACH_FORM);
  2362.     SETARG(XmNvisibleItemCount, pbp->res_vis_count);
  2363.     pbp->plist_widget = XmCreateScrolledList(pbp->pf_form,
  2364.                     "printerSelectionList",
  2365.                     ARGLIST);
  2366.     XtManageChild(pbp->plist_widget);
  2367.  
  2368.     /*
  2369.      * Register the printer selection and action callbacks. The
  2370.      * selection callback is called when a printer is selected
  2371.      * with a single click from the list. The action callback is
  2372.      * invoked when a printer on the list is double-clicked.
  2373.      */
  2374.     XtAddCallback(pbp->plist_widget, XmNbrowseSelectionCallback,
  2375.                     PrinterSelectedCB, (XtPointer)pb);
  2376.     XtAddCallback(pbp->plist_widget, XmNdefaultActionCallback,
  2377.                     PrinterSelectedCB, (XtPointer)pb);
  2378.  
  2379.     /*
  2380.      * Add the normal and default printer fonts to the list's fontlist
  2381.      */
  2382.     printer_entry = XmFontListEntryCreate(PRINTER_CHARSET,
  2383.                     XmFONT_IS_FONT,
  2384.                     pbp->res_printer_font);
  2385.     defprinter_entry = XmFontListEntryCreate(DEF_PRINTER_CHARSET,
  2386.                     XmFONT_IS_FONT,
  2387.                     pbp->res_def_printer_font);
  2388.     STARTARGS;
  2389.     SETARG(XmNfontList, &flist);
  2390.     XtGetValues(pbp->plist_widget, ARGLIST);
  2391.     nlist = XmFontListCopy(flist);
  2392.     nlist = XmFontListAppendEntry(nlist, printer_entry);
  2393.     nlist = XmFontListAppendEntry(nlist, defprinter_entry);
  2394.     STARTARGS;
  2395.     SETARG(XmNfontList, nlist);
  2396.     XtSetValues(pbp->plist_widget, ARGLIST);
  2397.     XmFontListFree(nlist);
  2398.     XmFontListEntryFree(&printer_entry);
  2399.     XmFontListEntryFree(&defprinter_entry);
  2400.  
  2401.     /*
  2402.      * Create the print job option area
  2403.      */
  2404.     pbp->option_form = XtCreateWidget("optionForm", xmFormWidgetClass,
  2405.                     (Widget)pb, NULL, 0);
  2406.     if (pbp->res_show_opts)
  2407.     XtManageChild(pbp->option_form);
  2408.     STARTARGS;
  2409.     SETARG(XmNlabelString, pbp->res_opts_label);
  2410.     SETARG(XmNalignment, XmALIGNMENT_BEGINNING);
  2411.     SETARG(XmNtopAttachment, XmATTACH_FORM);
  2412.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2413.     pbp->opts_label_widget = XtCreateManagedWidget(DEF_OPTS_LABEL,
  2414.                     xmLabelWidgetClass,
  2415.                     pbp->option_form, ARGLIST);
  2416.     STARTARGS;
  2417.     SETARG(XmNscrollingPolicy, XmAUTOMATIC);
  2418.     SETARG(XmNvisualPolicy, XmVARIABLE);
  2419.     SETARG(XmNtopAttachment, XmATTACH_WIDGET);
  2420.     SETARG(XmNtopWidget, pbp->opts_label_widget);
  2421.     SETARG(XmNbottomAttachment, XmATTACH_FORM);
  2422.     SETARG(XmNrightAttachment, XmATTACH_FORM);
  2423.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  2424.     pbp->opts_sw_widget = XtCreateManagedWidget("optionSWindow",
  2425.                     xmScrolledWindowWidgetClass,
  2426.                     pbp->option_form, ARGLIST);
  2427.     STARTARGS;
  2428.     SETARG(XmNorientation, XmVERTICAL);
  2429.     SETARG(XmNpacking, XmPACK_TIGHT);
  2430.     SETARG(XmNadjustMargin, False);
  2431.     SETARG(XmNadjustLast, False);
  2432.     pbp->opts_rc_widget = XtCreateManagedWidget("optionRowC",
  2433.                     xmRowColumnWidgetClass,
  2434.                     pbp->opts_sw_widget, ARGLIST);
  2435.     STARTARGS;
  2436.     SETARG(XmNworkWindow, pbp->opts_rc_widget);
  2437.     XtSetValues(pbp->opts_sw_widget, ARGLIST);
  2438.  
  2439.     /*
  2440.      * Set the scrolled window clip window background
  2441.      * to the color same as the RC window background
  2442.      */
  2443.     STARTARGS;
  2444.     SETARG(XmNclipWindow, &clip);
  2445.     XtGetValues(pbp->opts_sw_widget, ARGLIST);
  2446.     if (clip) {
  2447.         STARTARGS;
  2448.         SETARG(XmNbackground, &bg);
  2449.         XtGetValues(pbp->opts_rc_widget, ARGLIST);
  2450.         STARTARGS;
  2451.         SETARG(XmNbackground, bg);
  2452.         XtSetValues(clip, ARGLIST);
  2453.     }
  2454.  
  2455.     CreateOptionArea(pbp, pbp->opts_rc_widget);
  2456. }
  2457.  
  2458.  
  2459. /**************************************************************************
  2460.  *
  2461.  * Function: CreateOptionArea
  2462.  *
  2463.  * Description: Creates the print job option area. This is the area
  2464.  *    where print job options are set (eg. number of copies).
  2465.  *
  2466.  * Parameters: 
  2467.  *    pbp (I) - this widget's instance part
  2468.  *    parent (I) - parent widget ID
  2469.  *
  2470.  * Return: none
  2471.  *
  2472.  **************************************************************************/
  2473.  
  2474. static void CreateOptionArea(PuiPrintBoxPart *pbp, Widget parent)
  2475. {
  2476.     register int i;
  2477.  
  2478.     /*
  2479.      * Create each option's UI
  2480.      */
  2481.     for (i = 0; i < num_options; i++)
  2482.     option_list[i].create_func(pbp, parent);
  2483. }
  2484.  
  2485.  
  2486. /**************************************************************************
  2487.  *
  2488.  * Function: CalculateMySize
  2489.  *
  2490.  * Description: Calculates the required overall size for this widget
  2491.  *    based on the size of the children.
  2492.  *
  2493.  * Parameters: 
  2494.  *    pb (I) - this widget
  2495.  *    total_widthp (O) - required total width
  2496.  *    total_heightp (O) - required total width
  2497.  *
  2498.  * Return: none
  2499.  *
  2500.  **************************************************************************/
  2501.  
  2502. static void CalculateMySize(PuiPrintBoxWidget pb, int *total_widthp,
  2503.                         int *total_heightp)
  2504. {
  2505.     PuiPrintBoxPart *pbp = &pb->printBox;
  2506.     int plist_width, plist_height;
  2507.     int option_width, option_height;
  2508.     int work_width, work_height;
  2509.     int control_width, control_height;
  2510.  
  2511.     /*
  2512.      * Get the dimensions of the filename/printer list form
  2513.      */
  2514.     plist_width = WIDTH(pbp->pf_form);
  2515.     plist_height = HEIGHT(pbp->pf_form);
  2516.  
  2517.     /*
  2518.      * Get the dimensions of the option area form
  2519.      */
  2520.     if (pbp->res_show_opts) {
  2521.         option_width = WIDTH(pbp->option_form);
  2522.         option_height = HEIGHT(pbp->option_form);
  2523.     }
  2524.  
  2525.     /*
  2526.      * If a work area has been specified get its dimensions
  2527.      */
  2528.     if (pbp->work_area && XtIsManaged(pbp->work_area)) {
  2529.         work_width = WIDTH(pbp->work_area);
  2530.         work_height = HEIGHT(pbp->work_area) + VERT_SPACING(pb);
  2531.     } else {
  2532.         work_width = 0;
  2533.         work_height = 0;
  2534.     }
  2535.  
  2536.     /*
  2537.      * Determine the height and width of the control area
  2538.      */
  2539.     control_width = plist_width;
  2540.     if (pbp->res_show_opts) {
  2541.     control_width += option_width + HORIZ_SPACING(pb);
  2542.     control_height = option_height;
  2543.     } else
  2544.         control_height = plist_height;
  2545.  
  2546.     /*
  2547.      * Determine the overall dimensions of the widget excluding
  2548.      * outer margins
  2549.      */
  2550.     *total_widthp = MAX(work_width, control_width);
  2551.     *total_widthp = MAX(WIDTH(pbp->action_form), *total_widthp);
  2552.  
  2553.     *total_heightp = work_height + control_height + HEIGHT(pbp->action_form) +
  2554.                             VERT_SPACING(pb);
  2555.     if (pbp->separator && XtIsManaged(pbp->separator))
  2556.     *total_heightp += HEIGHT(pbp->separator) + VERT_SPACING(pb);
  2557.  
  2558.     /*
  2559.      * Add the outer margins to overall dimensions
  2560.      */
  2561.     *total_widthp += 2 * MARGIN_WIDTH(pb);
  2562.     *total_heightp += 2 * MARGIN_HEIGHT(pb);
  2563. }
  2564.  
  2565.  
  2566. /**************************************************************************
  2567.  *
  2568.  * Function: DoLayout
  2569.  *
  2570.  * Description: Positions and sizes the child widgets based on the
  2571.  *    widgets overall dimensions.
  2572.  *
  2573.  * Parameters: 
  2574.  *    pb (I) - this widget
  2575.  *
  2576.  * Return: none
  2577.  *
  2578.  **************************************************************************/
  2579.  
  2580. static void DoLayout(PuiPrintBoxWidget pb)
  2581. {
  2582.     PuiPrintBoxPart *pbp = &pb->printBox;
  2583.     int usable_width, usable_height;
  2584.     int height_left, width_left;
  2585.     Position x, y;
  2586.  
  2587.     /*
  2588.      * Determine the usable area, ie. overall dimensions
  2589.      * minus outer margins
  2590.      */
  2591.     width_left = usable_width = WIDTH(pb) - 2 * MARGIN_WIDTH(pb);
  2592.     height_left = usable_height = HEIGHT(pb) - 2 * MARGIN_HEIGHT(pb);
  2593.  
  2594.     /*
  2595.      * Configure action area
  2596.      */
  2597.     x = MARGIN_WIDTH(pb);
  2598.     y = usable_height - HEIGHT(pbp->action_form) + MARGIN_HEIGHT(pb);
  2599.     XtConfigureWidget(pbp->action_form, x, y,
  2600.             usable_width,
  2601.             HEIGHT(pbp->action_form),
  2602.             BWIDTH(pbp->action_form));
  2603.     height_left -= (HEIGHT(pbp->action_form) + VERT_SPACING(pb));
  2604.  
  2605.     /*
  2606.      * Configure separator
  2607.      */
  2608.     if (pbp->separator && XtIsManaged(pbp->separator)) {
  2609.         height_left -= (HEIGHT(pbp->separator) + VERT_SPACING(pb));
  2610.     y -= (HEIGHT(pbp->separator) + VERT_SPACING(pb));
  2611.         XtConfigureWidget(pbp->separator, 0, y,
  2612.             usable_width + 2 * MARGIN_WIDTH(pb),
  2613.             HEIGHT(pbp->separator),
  2614.             BWIDTH(pbp->separator));
  2615.     }
  2616.  
  2617.     /*
  2618.      * Configure work area
  2619.      */
  2620.     x = MARGIN_WIDTH(pb);
  2621.     y = MARGIN_HEIGHT(pb);
  2622.     if (pbp->work_area && XtIsManaged(pbp->work_area)) {
  2623.         if (height_left < HEIGHT(pbp->work_area))
  2624.         y = height_left - HEIGHT(pbp->work_area) + MARGIN_HEIGHT(pb);
  2625.         XtConfigureWidget(pbp->work_area, x, y,
  2626.             usable_width,
  2627.             HEIGHT(pbp->work_area),
  2628.             BWIDTH(pbp->work_area));
  2629.     height_left -= (HEIGHT(pbp->work_area) + VERT_SPACING(pb));
  2630.     y += HEIGHT(pbp->work_area) + VERT_SPACING(pb);
  2631.     }
  2632.  
  2633.     /*
  2634.      * Configure filename/printer list and option areas
  2635.      */
  2636.     if (height_left > 0) {
  2637.         x = MARGIN_WIDTH(pb);
  2638.     if (XtIsRealized(pbp->pf_form))
  2639.         XtMapWidget(pbp->pf_form);
  2640.         if (pbp->res_show_opts) {
  2641.             XtConfigureWidget(pbp->pf_form, x, y,
  2642.                 WIDTH(pbp->pf_form),
  2643.                     height_left,
  2644.                     BWIDTH(pbp->pf_form));
  2645.             width_left -= (WIDTH(pbp->pf_form) + HORIZ_SPACING(pb));
  2646.             x += WIDTH(pbp->pf_form) + HORIZ_SPACING(pb);
  2647.         if (width_left > 0) {
  2648.         if (XtIsRealized(pbp->option_form))
  2649.                 XtMapWidget(pbp->option_form);
  2650.                 XtConfigureWidget(pbp->option_form, x, y,
  2651.                 width_left,
  2652.                     height_left,
  2653.                     BWIDTH(pbp->option_form));
  2654.         } else {
  2655.         XtUnmapWidget(pbp->option_form);
  2656.         }
  2657.         } else {
  2658.             XtConfigureWidget(pbp->pf_form, x, y,
  2659.                 usable_width, height_left,
  2660.                     BWIDTH(pbp->pf_form));
  2661.         }
  2662.     } else {
  2663.     XtUnmapWidget(pbp->pf_form);
  2664.         if (pbp->res_show_opts)
  2665.         XtUnmapWidget(pbp->option_form);
  2666.     }
  2667. }
  2668.  
  2669.  
  2670. /**************************************************************************
  2671.  *
  2672.  * Function: UpdateLabel
  2673.  *
  2674.  * Description: Sets the specified widget's label string based on the
  2675.  *    specified string resource. Used by the SetValues routine.
  2676.  *
  2677.  * Parameters: 
  2678.  *    w (I) - widget whose label string is to be changed
  2679.  *    res_name (I) - resource name for the label
  2680.  *    labelp (I) - compound string specifying the label
  2681.  *
  2682.  * Return: none
  2683.  *
  2684.  **************************************************************************/
  2685.  
  2686. static void UpdateLabel(Widget w, String res_name, XmString *labelp)
  2687. {
  2688.     Arg arg;
  2689.  
  2690.     if (!w)
  2691.     return;
  2692.     XtSetArg(arg, res_name, *labelp);
  2693.     XtSetValues(w, &arg, 1);
  2694.     *labelp = NULL;
  2695. }
  2696.  
  2697.  
  2698. /**************************************************************************
  2699.  *
  2700.  * Function: SetPrinterList
  2701.  *
  2702.  * Description: Obtains a list of known printers, displays them in the
  2703.  *    printer selection list and selects an appropriate printer based
  2704.  *    on previous selections, default printer, etc. Also supervises
  2705.  *    construction of the printer specific options list.
  2706.  *
  2707.  * Parameters:
  2708.  *    pb (I) - this widget
  2709.  *
  2710.  * Return: 0 if no error occurred while setting the printer list.
  2711.  *    Otherwise, SLerrno is returned.
  2712.  *
  2713.  **************************************************************************/
  2714.  
  2715. static int SetPrinterList(PuiPrintBoxWidget pb)
  2716. {
  2717.     register int i, len;
  2718.     register int norm_spacing, def_spacing, max_spacing;
  2719.     char buffer[MAX_LINE], *formal_name;
  2720.     SLPrinterStruct *prptr;
  2721.     XmString *printers_str, str1, str2;
  2722.     PuiPrintBoxPart *pbp = &pb->printBox;
  2723.     XmFontList flist;
  2724.     DEFARGS(10);
  2725.  
  2726.     /*
  2727.      * Clear the default printer name, if any
  2728.      */
  2729.     if (pbp->res_default_printer) {
  2730.           free((char*)pbp->res_default_printer);
  2731.     pbp->res_default_printer = NULL;
  2732.     }
  2733.  
  2734.     /*
  2735.      * Destroy the printer specific options list, if any
  2736.      */
  2737.     if (pbp->printer_options && pbp->res_num_printers) {
  2738.     for (i = 0; i < pbp->res_num_printers; i++)
  2739.         XtFree((char*)pbp->printer_options[i].option_str);
  2740.     XtFree((char*)pbp->printer_options);
  2741.     pbp->printer_options = NULL;
  2742.     }
  2743.  
  2744.     /*
  2745.      * Get the list of known printers. We want to copy the list
  2746.      * returned from the libspool function since it is a pointer
  2747.      * to internal storage.
  2748.      */
  2749.     FreePrinterList(pbp->res_printer_list, pbp->res_num_printers);
  2750.     pbp->res_printer_list = NULL;
  2751.     if (SLGetPrinterList(&prptr, &pbp->res_num_printers) < 0)
  2752.     return SLerrno;
  2753.     PrintSensitiveCB(NULL, (XtPointer)pbp, NULL);
  2754.     if (!pbp->res_num_printers)
  2755.     return 0;
  2756.     pbp->res_printer_list = CopyPrinterList(prptr, pbp->res_num_printers);
  2757.  
  2758.     /*
  2759.      * Create the printer specific options list
  2760.      */
  2761.     pbp->printer_options = (PuiPrinterOption*)XtMalloc(pbp->res_num_printers *
  2762.                         sizeof(PuiPrinterOption));
  2763.     for (i = 0; i < pbp->res_num_printers; i++) {
  2764.     pbp->printer_options[i].option_str =
  2765.         ReadPrinterOptionsFile(pbp->res_printer_list[i].local_name);
  2766.     pbp->printer_options[i].modified = False;
  2767.     }
  2768.  
  2769.     /*
  2770.      * Calculate the horizontal spacing for the printer type
  2771.      * labels in the printers list
  2772.      */
  2773.     norm_spacing = MAX_PNAME + 4;
  2774.     STARTARGS;
  2775.     SETARG(XmNfontList, &flist);
  2776.     XtGetValues(pbp->plist_widget, ARGLIST);
  2777.     str1 = XmStringCreate(" ", PRINTER_CHARSET);
  2778.     str2 = XmStringCreate(" ", DEF_PRINTER_CHARSET);
  2779.     def_spacing = (int)((float)norm_spacing *
  2780.                 (float)XmStringWidth(flist, str1) /
  2781.                 (float)XmStringWidth(flist, str2) + 0.5);
  2782.     max_spacing = (norm_spacing > def_spacing) ? norm_spacing: def_spacing;
  2783.     XmStringFree(str1);
  2784.     XmStringFree(str2);
  2785.  
  2786.     /*
  2787.      * Display the printers in the selection list
  2788.      */
  2789.     printers_str = (pbp->res_num_printers > 0) ?
  2790.     (XmString*)XtMalloc(pbp->res_num_printers*sizeof(XmString)): NULL;
  2791.     for (i = 0, prptr = pbp->res_printer_list; i < pbp->res_num_printers;
  2792.                             i++, prptr++) {
  2793.     if ((len = strlen(prptr->local_name)) > MAX_PNAME)
  2794.         len = MAX_PNAME;
  2795.     (void)bzero(buffer, MAX_LINE);
  2796.     (void)memset(buffer, ' ', max_spacing);
  2797.     (void)memcpy(buffer, prptr->local_name, len);
  2798.     formal_name = (prptr->is_class) ? "Printer Class": prptr->formal_name;
  2799.     if (prptr->is_def) {
  2800.         (void)strncpy(buffer + def_spacing, formal_name, MAX_FORMALNAME);
  2801.         printers_str[i] = XmStringCreate(buffer, DEF_PRINTER_CHARSET);
  2802.             pbp->res_default_printer = strdup(prptr->local_name);
  2803.     } else {
  2804.         (void)strncpy(buffer + norm_spacing, formal_name, MAX_FORMALNAME);
  2805.         printers_str[i] = XmStringCreate(buffer, PRINTER_CHARSET);
  2806.     }
  2807.     }
  2808.     STARTARGS;
  2809.     SETARG(XmNitems, printers_str);
  2810.     SETARG(XmNitemCount, pbp->res_num_printers);
  2811.     XtSetValues(pbp->plist_widget, ARGLIST);
  2812.     for (i = 0; i < pbp->res_num_printers; i++)
  2813.     XmStringFree(printers_str[i]);
  2814.     if (pbp->res_num_printers > 0)
  2815.         XtFree((char*)printers_str);
  2816.  
  2817.     return 0;
  2818. }
  2819.  
  2820.  
  2821. /**************************************************************************
  2822.  *
  2823.  * Function: FreePrinterList
  2824.  *
  2825.  * Description: Frees the storage associated with the specified printer
  2826.  *    list.
  2827.  *
  2828.  * Parameters: 
  2829.  *    printer_list (I) - array of printer info structures
  2830.  *    num_printers (I) - number of items in the array
  2831.  *
  2832.  * Return: none
  2833.  *
  2834.  **************************************************************************/
  2835.  
  2836. static void FreePrinterList(SLPrinterStruct *printer_list, int num_printers)
  2837. {
  2838.     register SLPrinterStruct *prptr;
  2839.     register int i;
  2840.  
  2841.     if (!num_printers || !printer_list)
  2842.     return;
  2843.  
  2844.     for (i = 0, prptr = printer_list; i < num_printers; i++, prptr++) {
  2845.     if (prptr->local_name) XtFree(prptr->local_name);
  2846.     if (prptr->formal_name) XtFree(prptr->formal_name);
  2847.     if (prptr->type) XtFree(prptr->type);
  2848.     if (prptr->dev) XtFree(prptr->dev);
  2849.     if (prptr->remote_host) XtFree(prptr->remote_host);
  2850.     if (prptr->remote_name) XtFree(prptr->remote_name);
  2851.     }
  2852.     XtFree((char*)printer_list);
  2853. }
  2854.  
  2855.  
  2856. /**************************************************************************
  2857.  *
  2858.  * Function: CopyPrinterList
  2859.  *
  2860.  * Description: Makes a copy of the specified printer list.
  2861.  *
  2862.  * Parameters: 
  2863.  *    printer_list (I) - array of printer structures to copy.
  2864.  *    num_printers (I) - number of printers in array
  2865.  *
  2866.  * Return: Pointer to copy of the printer list. If is the caller's
  2867.  *    responsibility to free this storage.
  2868.  *
  2869.  **************************************************************************/
  2870.  
  2871. static SLPrinterStruct* CopyPrinterList(SLPrinterStruct *printer_list,
  2872.                     int num_printers)
  2873. {
  2874.     SLPrinterStruct *plist;
  2875.     register SLPrinterStruct *orig_ptr, *new_ptr;
  2876.     register int i;
  2877.  
  2878.     if (!num_printers || !printer_list)
  2879.     return NULL;
  2880.  
  2881.     plist = (SLPrinterStruct*)XtMalloc(num_printers * sizeof(SLPrinterStruct));
  2882.  
  2883.     for (i = 0, orig_ptr = printer_list, new_ptr = plist;
  2884.             i < num_printers; i++, orig_ptr++, new_ptr++) {
  2885.     new_ptr->local_name = (orig_ptr->local_name)?
  2886.                 XtNewString(orig_ptr->local_name): NULL;
  2887.     new_ptr->formal_name = (orig_ptr->formal_name)?
  2888.                 XtNewString(orig_ptr->formal_name): NULL;
  2889.     new_ptr->type = (orig_ptr->type)? XtNewString(orig_ptr->type): NULL;
  2890.     new_ptr->dev = (orig_ptr->dev)? XtNewString(orig_ptr->dev): NULL;
  2891.     new_ptr->remote_host = (orig_ptr->remote_host)?
  2892.                 XtNewString(orig_ptr->remote_host): NULL;
  2893.     new_ptr->remote_name = (orig_ptr->remote_name)?
  2894.                 XtNewString(orig_ptr->remote_name): NULL;
  2895.     new_ptr->is_def = orig_ptr->is_def;
  2896.     new_ptr->is_class = orig_ptr->is_class;
  2897.     new_ptr->is_networked = orig_ptr->is_networked;
  2898.     }
  2899.  
  2900.     return plist;
  2901. }
  2902.  
  2903.  
  2904. /**************************************************************************
  2905.  *
  2906.  * Function: SetFilenames
  2907.  *
  2908.  * Description: Sets the filenames in the filename widget based on the
  2909.  *    resource.
  2910.  *
  2911.  * Parameters: 
  2912.  *    pbp (I) - this widget's instance part
  2913.  *
  2914.  * Return: none
  2915.  *
  2916.  **************************************************************************/
  2917.  
  2918. static void SetFilenames(PuiPrintBoxPart *pbp)
  2919. {
  2920.     if (pbp->res_filename)
  2921.         XmTextFieldSetString(pbp->files_widget, pbp->res_filename);
  2922.     else
  2923.         XmTextFieldSetString(pbp->files_widget, "");
  2924. }
  2925.  
  2926.  
  2927. /**************************************************************************
  2928.  *
  2929.  * Function: SetPrinter
  2930.  *
  2931.  * Description: Selects the printer based on previous selections, resources
  2932.  *    defaults, etc.
  2933.  *
  2934.  * Parameters: 
  2935.  *    pbp (I) - this widget's instance part
  2936.  *
  2937.  * Return: none
  2938.  *
  2939.  **************************************************************************/
  2940.  
  2941. static void SetPrinter(PuiPrintBoxPart *pbp)
  2942. {
  2943.     int printer_ind;
  2944.  
  2945.     printer_ind = pbp->selected_printer_index;
  2946.     if (printer_ind < 0) {
  2947.         if (pbp->res_printer)
  2948.         printer_ind = FindPrinter(pbp, pbp->res_printer);
  2949.     }
  2950.     if (printer_ind < 0) {
  2951.         if (pbp->res_default_printer)
  2952.         printer_ind = FindPrinter(pbp, pbp->res_default_printer);
  2953.     }
  2954.     if (printer_ind < 0)
  2955.     printer_ind = 0;
  2956.     XmListSelectPos(pbp->plist_widget, printer_ind + 1, True);
  2957.     XmListSetBottomPos(pbp->plist_widget, printer_ind + 1);
  2958. }
  2959.  
  2960.  
  2961. /**************************************************************************
  2962.  *
  2963.  * Function: PrintSensitiveCB
  2964.  *
  2965.  * Description: Checks whether there are printers available and at least
  2966.  *    one filename has been specified. If these conditions are true
  2967.  *    the print button is made sensitive, otherwise it is made in-
  2968.  *    sensitive.
  2969.  *
  2970.  * Parameters:
  2971.  *    w (I) - widget that invoked this callback
  2972.  *    client_data (I) - this widget's instance part
  2973.  *    call_data (I) - unused
  2974.  *
  2975.  * Return: none
  2976.  *
  2977.  **************************************************************************/
  2978. /* ARGSUSED */
  2979.  
  2980. static void PrintSensitiveCB(Widget w, XtPointer client_data,
  2981.                         XtPointer call_data)
  2982. {
  2983.     PuiPrintBoxPart *pbp = (PuiPrintBoxPart*)client_data;
  2984.     char *str;
  2985.     register char *sptr;
  2986.     Boolean sensitive = False;
  2987.  
  2988.     if (pbp->res_num_printers) {
  2989.     if (pbp->res_job_type == PuiPRINTJOB_FILENAME) {
  2990.         str = XmTextFieldGetString(pbp->files_widget);
  2991.         for (sptr = str; *sptr; sptr++) {
  2992.             if (!isspace((int)*sptr) && !iscntrl((int)*sptr)) {
  2993.                 sensitive = True;
  2994.             break;
  2995.             }
  2996.         }
  2997.         XtFree((char*)str);
  2998.     } else
  2999.         sensitive = True;
  3000.     }
  3001.  
  3002.     XtSetSensitive(pbp->printb_widget, sensitive);
  3003. }
  3004.  
  3005.  
  3006. /**************************************************************************
  3007.  *
  3008.  * Function: FindPrinter
  3009.  *
  3010.  * Description: Linearly searches the printer list looking for
  3011.  *    the specified printer name.
  3012.  *
  3013.  * Parameters: 
  3014.  *    pbp (I) - this widget's instance part
  3015.  *    printers (I) - list of printers
  3016.  *
  3017.  * Return: Returns the list index if the printer is found. Returns -1
  3018.  *    if the printer is not found.
  3019.  *
  3020.  **************************************************************************/
  3021.  
  3022. static int FindPrinter(PuiPrintBoxPart *pbp, char *pname)
  3023. {
  3024.     register int i;
  3025.  
  3026.     for (i = 0; i < pbp->res_num_printers; i++)
  3027.     if (!strcmp(pbp->res_printer_list[i].local_name, pname))
  3028.         break;
  3029.     return ((i == pbp->res_num_printers) ? -1: i);
  3030. }
  3031.  
  3032.  
  3033. /**************************************************************************
  3034.  *
  3035.  * Function: PrinterSelectedCB
  3036.  *
  3037.  * Description: Called when a printer from the printer list is single 
  3038.  *    clicked (selection) or double clicked (action).
  3039.  *
  3040.  * Parameters:
  3041.  *      w (I) - the invoking widget
  3042.  *    client_data (I) - this widget
  3043.  *      call_data (I) - list callback struct
  3044.  *
  3045.  * Return: none
  3046.  *
  3047.  **************************************************************************/
  3048. /* ARGSUSED */
  3049.  
  3050. static void PrinterSelectedCB(Widget w, XtPointer client_data,
  3051.                                 XtPointer call_data)
  3052. {
  3053.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3054.     PuiPrintBoxPart *pbp = &pb->printBox;
  3055.     PuiPrintBoxCallbackStruct pb_cb;
  3056.     XmListCallbackStruct *lcb = (XmListCallbackStruct*)call_data;
  3057.     XtCallbackList callback_list;
  3058.     register int pind;
  3059.     register char *pname;
  3060.  
  3061.     /*
  3062.      * If there are no printers in the list there is nothing to do
  3063.      */
  3064.     if (pbp->res_num_printers == 0)
  3065.     return;
  3066.  
  3067.     /*
  3068.      * Set a variable for convenience
  3069.      */
  3070.      pind = pbp->selected_printer_index;
  3071.  
  3072.     /*
  3073.      * Update the printer option string list if there
  3074.      * is a currently selected printer
  3075.      */
  3076.     if (pind >= 0)
  3077.         UpdatePrinterOption(pb, &pbp->printer_options[pind]);
  3078.  
  3079.     /*
  3080.      * Kill the options panel if an options panel instance exists for the
  3081.      * old printer. Do not kill the options panel if the original printer
  3082.      * is the same as the newly selected printer.
  3083.      */
  3084.     if (pind >= 0 && pbp->res_show_optionsbutton && pbp->option_panels &&
  3085.         pbp->option_panels[pind] &&
  3086.         (pbp->selected_printer_index != lcb->item_position - 1))
  3087.         _PuiOptionPanelKill(pbp->option_panels[pind], True);
  3088.  
  3089.     /*
  3090.      * Set the selected printer variable
  3091.      */
  3092.     pind = pbp->selected_printer_index = lcb->item_position - 1;
  3093.  
  3094.     /*
  3095.      * Set a variable for the printer name
  3096.      */
  3097.     pname = pbp->res_printer_list[pind].local_name;
  3098.  
  3099.     /*
  3100.      * Update the UI with the new printer's options
  3101.      */
  3102.     if (pbp->res_spec_opts)
  3103.     XtFree(pbp->res_spec_opts);
  3104.     pbp->res_spec_opts = XtNewString(pbp->printer_options[pind].option_str);
  3105.     SetOptionPrinterSpecific(pbp);
  3106.  
  3107.     /*
  3108.      * If we want option panels, determine if one exists for this printer
  3109.      * and create the option panel instance if it has not already been
  3110.      * created and register callbacks for it. We also set the options
  3111.      * button sensitivity accordingly.
  3112.      */
  3113.     if (pbp->res_show_optionsbutton && pbp->option_panels) {
  3114.     if (_PuiOptionPanelExists(pname)) {
  3115.         if (!pbp->option_panels[pind]) {
  3116.         pbp->option_panels[pind] =
  3117.             _PuiOptionPanelCreate(pbp->action_form, pname, True);
  3118.             if (pbp->option_panels[pind]) {
  3119.             _PuiOptionPanelSetCallback(pbp->option_panels[pind],
  3120.                         PuiNoptionPanelErrorCallback,
  3121.                         OptionErrorCB, (XtPointer)pb);
  3122.             _PuiOptionPanelSetCallback(pbp->option_panels[pind],
  3123.                         PuiNoptionPanelMapCallback,
  3124.                         OptionMappedCB, (XtPointer)pb);
  3125.             _PuiOptionPanelSetCallback(pbp->option_panels[pind],
  3126.                         PuiNoptionPanelDeathCallback,
  3127.                         OptionDeathCB, (XtPointer)pb);
  3128.             _PuiOptionPanelSetCallback(pbp->option_panels[pind],
  3129.                         PuiNoptionPanelDataCallback,
  3130.                         OptionDataCB, (XtPointer)pb);
  3131.             }
  3132.         }
  3133.         if (pbp->option_panels[pind])
  3134.             XtSetSensitive(pbp->optionsb_widget, True);
  3135.     } else {
  3136.         if (pbp->option_panels[pind]) {
  3137.         _PuiOptionPanelDestroy(pbp->option_panels[pind]);
  3138.         pbp->option_panels[pind] = NULL;
  3139.         }
  3140.         XtSetSensitive(pbp->optionsb_widget, False);
  3141.     }
  3142.     XFlush(XtDisplay((Widget)pb));
  3143.     }
  3144.  
  3145.     /*
  3146.      * Call any printer selection callbacks
  3147.      */
  3148.     InitCallback(&pb_cb);
  3149.     pb_cb.reason = (lcb->reason == XmCR_DEFAULT_ACTION) ? PuiCR_PR_ACTION:
  3150.                         PuiCR_PR_SELECT;
  3151.     pb_cb.selected_printer = pname;
  3152.     pb_cb.selected_position = lcb->item_position;
  3153.     callback_list = (lcb->reason == XmCR_DEFAULT_ACTION) ?
  3154.         pbp->res_pr_action_callback: pbp->res_pr_select_callback;
  3155.     XtCallCallbackList(w, callback_list, (XtPointer)&pb_cb);
  3156. }
  3157.  
  3158.  
  3159. /**************************************************************************
  3160.  *
  3161.  * Function: ActionAreaCB
  3162.  *
  3163.  * Description: All action area push buttons call this routine. This
  3164.  *    routine executes the appropriate callback list for the specified
  3165.  *    button. Note that the print button calls user specified callbacks
  3166.  *    before the internal print callback so that users can get in and
  3167.  *    change things before printing.
  3168.  *
  3169.  * Parameters: 
  3170.  *    w (I) - widget ID of button invoking this routine
  3171.  *    client_data (I) - printBox widget ID
  3172.  *    call_data (I) - XmPushButtonCallbackStruct
  3173.  *
  3174.  * Return: none
  3175.  *
  3176.  **************************************************************************/
  3177.  
  3178. static void ActionAreaCB(Widget w, XtPointer client_data,
  3179.                 XtPointer call_data)
  3180. {
  3181.     PuiPrintBoxCallbackStruct pb_cb;
  3182.     int button_id;
  3183.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3184.     XmAnyCallbackStruct *cb = (XmAnyCallbackStruct*)call_data;
  3185.     DEFARGS(5);
  3186.  
  3187.     /*
  3188.      * Initialize the callback struct and copy the X event that
  3189.      * triggered the callback and set the unused fields to sane values.
  3190.      */
  3191.     InitCallback(&pb_cb);
  3192.     pb_cb.event = cb->event;
  3193.  
  3194.     /*
  3195.      * Set the reason based on the button pushed
  3196.      */
  3197.     STARTARGS;
  3198.     SETARG(XmNuserData, &button_id);
  3199.     XtGetValues(w, ARGLIST);
  3200.     switch (button_id) {
  3201.     case PuiPRINTBOX_PRINT_BUTTON:
  3202.             pb_cb.reason = PuiCR_PRINT;
  3203.         XtCallCallbackList((Widget)pb, pb->printBox.res_print_callback,
  3204.                             (XtPointer)&pb_cb);
  3205.         break;
  3206.     case PuiPRINTBOX_USER1_BUTTON:
  3207.             pb_cb.reason = PuiCR_USER1;
  3208.         XtCallCallbackList((Widget)pb, pb->printBox.res_user1_callback,
  3209.                             (XtPointer)&pb_cb);
  3210.         break;
  3211.     case PuiPRINTBOX_USER2_BUTTON:
  3212.             pb_cb.reason = PuiCR_USER2;
  3213.         XtCallCallbackList((Widget)pb, pb->printBox.res_user2_callback,
  3214.                             (XtPointer)&pb_cb);
  3215.         break;
  3216.     case PuiPRINTBOX_USER3_BUTTON:
  3217.             pb_cb.reason = PuiCR_USER3;
  3218.         XtCallCallbackList((Widget)pb, pb->printBox.res_user3_callback,
  3219.                             (XtPointer)&pb_cb);
  3220.         break;
  3221.     case PuiPRINTBOX_USER4_BUTTON:
  3222.             pb_cb.reason = PuiCR_USER4;
  3223.         XtCallCallbackList((Widget)pb, pb->printBox.res_user4_callback,
  3224.                             (XtPointer)&pb_cb);
  3225.         break;
  3226.     case PuiPRINTBOX_CANCEL_BUTTON:
  3227.             pb_cb.reason = PuiCR_CANCEL;
  3228.         XtCallCallbackList((Widget)pb, pb->printBox.res_cancel_callback,
  3229.                             (XtPointer)&pb_cb);
  3230.         break;
  3231.     case PuiPRINTBOX_HELP_BUTTON:
  3232.             pb_cb.reason = PuiCR_HELP;
  3233.         XtCallCallbackList((Widget)pb, pb->printBox.res_help_callback,
  3234.                             (XtPointer)&pb_cb);
  3235.         break;
  3236.     }
  3237. }
  3238.  
  3239.  
  3240. /**************************************************************************
  3241.  *
  3242.  * Function: SubmitPrintJobCB
  3243.  *
  3244.  * Description: Handles the submittal of a print job. Note that this
  3245.  *    routine simply returns if the application is handling printing.
  3246.  *    Also this callback is called after any user registered Print button
  3247.  *    callbacks so that the user can change any resource of this widget
  3248.  *    (eg. print buffer) before the actual printing routine is run.
  3249.  *
  3250.  * Parameters: 
  3251.  *    w (I) - widget that invoked this callback
  3252.  *    client_data (I) - this widget
  3253.  *    call_data (I) - not used
  3254.  *
  3255.  * Return: none
  3256.  *
  3257.  **************************************************************************/
  3258. /* ARGSUSED */
  3259.  
  3260. static void SubmitPrintJobCB(Widget w, XtPointer client_data,
  3261.                             XtPointer call_data)
  3262. {
  3263.     SLPrintJob *job_info;
  3264.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3265.     PuiPrintBoxPart *pbp = &pb->printBox;
  3266.     PuiPrintBoxCallbackStruct pb_cb;
  3267.     register int i;
  3268.     char *filenames, *exp_filenames, *pname;
  3269.  
  3270.     /*
  3271.      * First make sure that user wants us to do printing
  3272.      */
  3273.     if (pbp->res_print_policy == PuiAPPLICATION_PRINTING)
  3274.     return;
  3275.  
  3276.     /*
  3277.      * Clear spooler specific option string
  3278.      */
  3279.     ClearPrinterOptions(pbp);
  3280.  
  3281.     /*
  3282.      * Get the option settings
  3283.      */
  3284.     for (i = 0; i < num_options; i++)
  3285.         option_list[i].get_func(pbp);
  3286.  
  3287.     /*
  3288.      * Set the printer name
  3289.      */
  3290.     pname = pbp->res_printer_list[pbp->selected_printer_index].local_name;
  3291.  
  3292.     /*
  3293.      * Submit the print job
  3294.      */
  3295.     switch (pbp->res_job_type) {
  3296.     case PuiPRINTJOB_DESCRIPTOR:
  3297.             job_info = SLSubmitJobFd(pbp->res_fd, pname,
  3298.             pbp->num_copies,
  3299.             pbp->copy_file,
  3300.             pbp->mail,
  3301.             pbp->job_title,
  3302.             pbp->options);
  3303.         break;
  3304.     case PuiPRINTJOB_BUFFER:
  3305.             job_info = SLSubmitJobBuf(pbp->res_buffer,
  3306.             (size_t)pbp->res_bufsize,
  3307.             pname,
  3308.             pbp->num_copies,
  3309.             pbp->copy_file,
  3310.             pbp->mail,
  3311.             pbp->job_title,
  3312.             pbp->options);
  3313.         break;
  3314.     case PuiPRINTJOB_FILENAME:
  3315.             filenames = XmTextFieldGetString(pbp->files_widget);
  3316.         exp_filenames = _PuiExpandFilenames(filenames);
  3317.             XtFree((char*)filenames);
  3318.             job_info = SLSubmitJob(exp_filenames, pname,
  3319.             pbp->num_copies,
  3320.             pbp->copy_file,
  3321.             pbp->mail,
  3322.             pbp->job_title,
  3323.             pbp->options);
  3324.             XtFree((char*)exp_filenames);
  3325.         break;
  3326.     default:
  3327.         break;
  3328.     }
  3329.  
  3330.     /*
  3331.      * If job_info != NULL call the callbacks for job info otherwise
  3332.      * call the callbacks for error condition.
  3333.      */
  3334.     if (job_info) {
  3335.     InitCallback(&pb_cb);
  3336.     pb_cb.reason = PuiCR_JOB_INFO;
  3337.     pb_cb.job_info = job_info;
  3338.     XtCallCallbackList((Widget)pb, pbp->res_jobinfo_callback,
  3339.                             (XtPointer)&pb_cb);
  3340.     } else
  3341.     HandleError(pb, SLerrno);
  3342. }
  3343.  
  3344.  
  3345. /**************************************************************************
  3346.  *
  3347.  * Function: OptionButtonCB
  3348.  *
  3349.  * Description: Called when the options button is pressed. The function
  3350.  *    attempts to exec an option panel program.
  3351.  *
  3352.  * Parameters: 
  3353.  *    w (I) - widget ID of button invoking this routine
  3354.  *    client_data (I) - this widget
  3355.  *    call_data (I) - XmPushButtonCallbackStruct
  3356.  *
  3357.  * Return: none
  3358.  *
  3359.  **************************************************************************/
  3360.  
  3361. static void OptionButtonCB(Widget w, XtPointer client_data,
  3362.                             XtPointer call_data)
  3363. {
  3364.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3365.     PuiPrintBoxPart *pbp = &pb->printBox;
  3366.     PuiOptionPanelArgs args;
  3367.     XtArgVal fnames, optstr;
  3368.  
  3369.     if (pbp->option_panels &&
  3370.             pbp->option_panels[pbp->selected_printer_index]) {
  3371.     /*
  3372.      * Set a busy cursor
  3373.      */
  3374.     SetCursor(pb, PuiCursorBusy);
  3375.  
  3376.     /*
  3377.      * Build the command line arguments for the option panel program
  3378.      */
  3379.     args.userName = pbp->user_name;
  3380.     SynthGetFilename((Widget)pb, offset(printBox.res_filename), &fnames);
  3381.     args.filenames = (char*)fnames;
  3382.         SynthGetOptionPrinterSpecific((Widget)pb,
  3383.                 offset(printBox.res_spec_opts), &optstr);
  3384.     args.options = (char*)optstr;
  3385.     args.clientXtOptions = NULL;
  3386.     args.numClientXtOptions = 0;
  3387.  
  3388.     /*
  3389.      * Launch the program and clean up
  3390.      */
  3391.     _PuiOptionPanelExec(pbp->option_panels[pbp->selected_printer_index],
  3392.                 &args);
  3393.         if (fnames) XtFree((char*)fnames);
  3394.         if (optstr) XtFree((char*)optstr);
  3395.  
  3396.     /*
  3397.      * Disable the type-in options field
  3398.      */
  3399.         SetTextFieldSensitivity(pbp, pbp->spec_options_widget, False);
  3400.     }
  3401. }
  3402.  
  3403.  
  3404. /**************************************************************************
  3405.  *
  3406.  * Function: OptionDataCB
  3407.  *
  3408.  * Description: Called when a printer option panel has an option string
  3409.  *    available. This occurs when either the apply or OK button is
  3410.  *    pressed on the option panel.
  3411.  *
  3412.  * Parameters: 
  3413.  *    panel (I) - pointer to the option panel structure for the panel
  3414.  *    client_data (I) - this widget
  3415.  *    cb (I) - callback information structure
  3416.  *
  3417.  * Return: None
  3418.  *
  3419.  **************************************************************************/
  3420.  
  3421. static void OptionDataCB(PuiOptionPanel *panel, XtPointer client_data,
  3422.                     PuiOptionPanelCallbackStruct *cb)
  3423. {
  3424.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3425.     PuiPrintBoxPart *pbp = &pb->printBox;
  3426.  
  3427.     /*
  3428.      * Make sure the busy cursor is cleared (in case we didn't detect the
  3429.      * option panel mapping).
  3430.      */
  3431.     SetCursor(pb, PuiCursorNormal);
  3432.  
  3433.     /*
  3434.      * Put the options string in the type-in field
  3435.      */
  3436.     if (pbp->res_spec_opts)
  3437.     XtFree(pbp->res_spec_opts);
  3438.     pbp->res_spec_opts = XtNewString(cb->options);
  3439.     SetOptionPrinterSpecific(pbp);
  3440. }
  3441.  
  3442.  
  3443. /**************************************************************************
  3444.  *
  3445.  * Function: OptionMappedCB
  3446.  *
  3447.  * Description: Called when a printer option panel is mapped to the screen
  3448.  *    for the first time.
  3449.  *
  3450.  * Parameters: 
  3451.  *    panel (I) - pointer to the option panel structure for the panel
  3452.  *    client_data (I) - this widget
  3453.  *    cb (I) - callback information structure
  3454.  *
  3455.  * Return: None
  3456.  *
  3457.  **************************************************************************/
  3458.  
  3459. static void OptionMappedCB(PuiOptionPanel *panel, XtPointer client_data,
  3460.                     PuiOptionPanelCallbackStruct *cb)
  3461. {
  3462.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3463.     PuiPrintBoxPart *pbp = &pb->printBox;
  3464.  
  3465.     /*
  3466.      * Clear the busy cursor
  3467.      */
  3468.     SetCursor(pb, PuiCursorNormal);
  3469. }
  3470.  
  3471.  
  3472. /**************************************************************************
  3473.  *
  3474.  * Function: OptionErrorCB
  3475.  *
  3476.  * Description: Called when a printer option panel has encountered an
  3477.  *    execution error.
  3478.  *
  3479.  * Parameters: 
  3480.  *    panel (I) - pointer to the option panel structure for the panel
  3481.  *    client_data (I) - this widget
  3482.  *    cb (I) - callback information structure
  3483.  *
  3484.  * Return: None
  3485.  *
  3486.  **************************************************************************/
  3487.  
  3488. static void OptionErrorCB(PuiOptionPanel *panel, XtPointer client_data,
  3489.                     PuiOptionPanelCallbackStruct *cb)
  3490. {
  3491.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3492.     PuiPrintBoxCallbackStruct pb_cb;
  3493.  
  3494.     InitCallback(&pb_cb);
  3495.     pb_cb.reason = PuiCR_OPT_ERROR;
  3496.     pb_cb.error_code = cb->errorCode;
  3497.     XtCallCallbackList((Widget)pb, pb->printBox.res_opt_error_callback,
  3498.                             (XtPointer)&pb_cb);
  3499. }
  3500.  
  3501.  
  3502. /**************************************************************************
  3503.  *
  3504.  * Function: OptionDeathCB
  3505.  *
  3506.  * Description: Called when a printer option panel terminates execution.
  3507.  *    This function will be called either when the option panel is
  3508.  *    killed programmatically or when the OK or cancel button is pressed.
  3509.  *
  3510.  * Parameters: 
  3511.  *    panel (I) - pointer to the option panel structure for the panel
  3512.  *    client_data (I) - this widget
  3513.  *    cb (I) - callback information structure
  3514.  *
  3515.  * Return: None
  3516.  *
  3517.  **************************************************************************/
  3518.  
  3519. static void OptionDeathCB(PuiOptionPanel *panel, XtPointer client_data,
  3520.                     PuiOptionPanelCallbackStruct *cb)
  3521. {
  3522.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3523.     PuiPrintBoxPart *pbp = &pb->printBox;
  3524.  
  3525.     /*
  3526.      * Make sure the busy cursor is cleared (in case we didn't detect the
  3527.      * option panel mapping).
  3528.      */
  3529.     SetCursor(pb, PuiCursorNormal);
  3530.  
  3531.     /*
  3532.      * Enable the type-in options field
  3533.      */
  3534.     SetTextFieldSensitivity(pbp, pbp->spec_options_widget, True);
  3535. }
  3536.  
  3537.  
  3538. /**************************************************************************
  3539.  *
  3540.  * Function: QueryForSaveCB
  3541.  *
  3542.  * Description: Called when the Save button is pressed. Function pops up
  3543.  *    a dialog which performs two jobs. Job one is to allow privilleged
  3544.  *    users the ability to save default options for a printer. The
  3545.  *    second job is to allow users to select among the printer's whose
  3546.  *    printer specific options have been modified.
  3547.  *
  3548.  * Parameters: 
  3549.  *    w (I) - widget ID of button invoking this routine
  3550.  *    client_data (I) - this widget
  3551.  *    call_data (I) - XmPushButtonCallbackStruct
  3552.  *
  3553.  * Return: none
  3554.  *
  3555.  **************************************************************************/
  3556.  
  3557. static void QueryForSaveCB(Widget w, XtPointer client_data,
  3558.                         XtPointer call_data)
  3559. {
  3560.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3561.     PuiPrintBoxPart *pbp = &pb->printBox;
  3562.     XmString printer_str;
  3563.     register int i;
  3564.     int num_modified;
  3565.  
  3566.     /*
  3567.      * Do not put up the dialog if it is already up
  3568.      */
  3569.     if (XtIsManaged(pbp->save_dialog_widget))
  3570.     return;
  3571.  
  3572.     /*
  3573.      * Update the printer option string list if there
  3574.      * is a currently selected printer
  3575.      */
  3576.     if (pbp->selected_printer_index >= 0)
  3577.         UpdatePrinterOption(pb,
  3578.             &pbp->printer_options[pbp->selected_printer_index]);
  3579.  
  3580.     /*
  3581.      * Now cycle through the array of printer specific options. Add
  3582.      * the printer to the list if its options have been marked as
  3583.      * modified. If no printers have modified options, add the current
  3584.      * printer. If there is no current printer we leave the list
  3585.      * empty. Note that we do not include printer classes on the list
  3586.      * since printer options have no meaning for a printer class. Note
  3587.      * also that items are added in a selected state
  3588.      */
  3589.     XmListDeleteAllItems(pbp->save_list_widget);
  3590.     num_modified = 0;
  3591.     for (i = 0; i < pbp->res_num_printers; i++) {
  3592.     if (pbp->printer_options[i].modified &&
  3593.                 !pbp->res_printer_list[i].is_class) {
  3594.         printer_str =
  3595.         XmStringCreateLocalized(pbp->res_printer_list[i].local_name);
  3596.         XmListAddItemUnselected(pbp->save_list_widget, printer_str, 0);
  3597.         XmListSelectPos(pbp->save_list_widget, 0, False);
  3598.         XmStringFree(printer_str);
  3599.         num_modified++;
  3600.     }
  3601.     }
  3602.     if (!num_modified && pbp->selected_printer_index >= 0 &&
  3603.         !pbp->res_printer_list[pbp->selected_printer_index].is_class) {
  3604.         printer_str = XmStringCreateLocalized(
  3605.         pbp->res_printer_list[pbp->selected_printer_index].local_name);
  3606.     XmListAddItemUnselected(pbp->save_list_widget, printer_str, 0);
  3607.     XmListSelectPos(pbp->save_list_widget, 0, False);
  3608.     XmStringFree(printer_str);
  3609.     }
  3610.  
  3611.     /*
  3612.      * Pop up the dialog
  3613.      */
  3614.     XtManageChild(pbp->save_dialog_widget);
  3615. }
  3616.  
  3617.  
  3618. /**************************************************************************
  3619.  *
  3620.  * Function: SaveOptionsCB
  3621.  *
  3622.  * Description: Supervises the saving of the printer specific and spooler
  3623.  *    options.
  3624.  *
  3625.  * Parameters: 
  3626.  *    w (I) - widget ID of button invoking this routine
  3627.  *    client_data (I) - this widget
  3628.  *    call_data (I) - XmPushButtonCallbackStruct
  3629.  *
  3630.  * Return: none
  3631.  *
  3632.  **************************************************************************/
  3633.  
  3634. static void SaveOptionsCB(Widget w, XtPointer client_data,
  3635.                         XtPointer call_data)
  3636. {
  3637.     PuiPrintBoxWidget pb = (PuiPrintBoxWidget)client_data;
  3638.     PuiPrintBoxPart *pbp = &pb->printBox;
  3639.     XmPushButtonCallbackStruct *cb = (XmPushButtonCallbackStruct*)call_data;
  3640.     PuiPrintBoxCallbackStruct pb_cb;
  3641.     XmString *plist_str;
  3642.     int i, pind, num_plist, save_type;
  3643.     char *pname;
  3644.     DEFARGS(10);
  3645.  
  3646.     /*
  3647.      * If apply button pressed, pop down dialog. We need to do this
  3648.      * explicitly since the apply callback does not trigger the
  3649.      * autoUnamange callback.
  3650.      */
  3651.     if (cb->reason == XmCR_APPLY)
  3652.     XtUnmanageChild(pbp->save_dialog_widget);
  3653.  
  3654.     /*
  3655.      * Save the spooler options. If the write fails, send
  3656.      * out the error to the error callback list.
  3657.      */
  3658.     if (WriteSpoolerOptionsFile(pb) < 0) {
  3659.     HandleError(pb, SLerrno);
  3660.     return;
  3661.     }
  3662.  
  3663.     /*
  3664.      * Get the selected printers in the save options list
  3665.      */
  3666.     STARTARGS;
  3667.     SETARG(XmNselectedItems, &plist_str);
  3668.     SETARG(XmNselectedItemCount, &num_plist);
  3669.     XtGetValues(pbp->save_list_widget, ARGLIST);
  3670.  
  3671.     /*
  3672.      * Determine whether we are saving printer specific
  3673.      * options for just this user or for all users
  3674.      */
  3675.     save_type = (cb->reason == XmCR_OK)? SL_SAVE_USER: SL_SAVE_DEFAULT;
  3676.  
  3677.     /*
  3678.      * For each selected printer save the options and mark
  3679.      * the corresponding entries in the printer options list
  3680.      * as unmodified.
  3681.      */
  3682.     for (i = 0; i < num_plist; i++) {
  3683.     if (!XmStringGetLtoR(plist_str[i], XmFONTLIST_DEFAULT_TAG, &pname))
  3684.         continue;
  3685.     if ((pind = FindPrinter(pbp, pname)) < 0)
  3686.         continue;
  3687.     if (WritePrinterOptionsFile(pname,
  3688.         pbp->printer_options[pind].option_str, save_type) < 0) {
  3689.         HandleError(pb, SLerrno);
  3690.         XtFree(pname);
  3691.         return;
  3692.     }
  3693.     pbp->printer_options[pind].modified = False;
  3694.     XtFree(pname);
  3695.     }
  3696.  
  3697.     /*
  3698.      * Now call the folks who want to know that we successfully
  3699.      * saved the options files. Copy the X event that triggered
  3700.      * the callback and set the unused fields to sane values.
  3701.      */
  3702.     InitCallback(&pb_cb);
  3703.     pb_cb.reason = PuiCR_SAVE;
  3704.     pb_cb.event = cb->event;
  3705.     XtCallCallbackList((Widget)pb, pbp->res_save_callback, (XtPointer)&pb_cb);
  3706. }
  3707.  
  3708.  
  3709. /**************************************************************************
  3710.  *
  3711.  * Function: CreateSaveDialog
  3712.  *
  3713.  * Description: Creates the options saving dialog. This dialog queries
  3714.  *    the user for the printers for which options are to be saved and
  3715.  *    if user is privilleged, allows saving of printer default options
  3716.  *    for all users.
  3717.  *
  3718.  * Parameters: 
  3719.  *    pb (I) - this widget
  3720.  *
  3721.  * Return: Created dialog widget
  3722.  *
  3723.  **************************************************************************/
  3724.  
  3725. static Widget CreateSaveDialog(PuiPrintBoxWidget pb)
  3726. {
  3727.     PuiPrintBoxPart *pbp = &pb->printBox;
  3728.     Widget dialog, form, label;
  3729.     DEFARGS(20);
  3730.  
  3731.     /*
  3732.      * Create the dialog. Note that the action area button labels
  3733.      * depend on who we are. If we are root or lp we add the Apply button
  3734.      * and use that for saving printer settings for all users.
  3735.      */
  3736.     STARTARGS;
  3737.     SETARG(XmNdialogTitle, pbp->res_savedlg_title_label);
  3738.     SETARG(XmNcancelLabelString, pbp->res_savedlg_cancelb_label);
  3739.     if (strcmp(pbp->user_name, "root") && strcmp(pbp->user_name, "lp")) {
  3740.         SETARG(XmNokLabelString, pbp->res_savedlg_saveb_label);
  3741.         dialog = XmCreatePromptDialog((Widget)pb, "saveDialog", ARGLIST);
  3742.     } else {
  3743.         SETARG(XmNokLabelString, pbp->res_savedlg_userb_label);
  3744.         SETARG(XmNapplyLabelString, pbp->res_savedlg_allb_label);
  3745.         dialog = XmCreatePromptDialog((Widget)pb, "saveDialog", ARGLIST);
  3746.     XtManageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_APPLY_BUTTON));
  3747.     }
  3748.  
  3749.     /*
  3750.      * Remove the canned dialog message. Remove the separator if the
  3751.      * parent dialog's separator has been unmanaged. And remove the help
  3752.      * button since it is not needed and makes the dialog too wide.
  3753.      */
  3754.     XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  3755.     XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_SELECTION_LABEL));
  3756.     XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_TEXT));
  3757.     if (XtIsManaged(pbp->separator) == False)
  3758.         XtUnmanageChild(XmSelectionBoxGetChild(dialog, XmDIALOG_SEPARATOR));
  3759.  
  3760.     /*
  3761.      * Create a form as a child of the dialog
  3762.      */
  3763.     form = XtCreateManagedWidget("saveForm", xmFormWidgetClass,
  3764.                     dialog, NULL, 0);
  3765.  
  3766.     /*
  3767.      * Create a title for the printer list
  3768.      */
  3769.     STARTARGS;
  3770.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  3771.     SETARG(XmNtopAttachment, XmATTACH_FORM);
  3772.     SETARG(XmNlabelString, pbp->res_savedlg_msg_label);
  3773.     pbp->save_msg_widget = XtCreateManagedWidget("saveMessage",
  3774.                     xmLabelWidgetClass, form, ARGLIST);
  3775.  
  3776.     /*
  3777.      * Create the list
  3778.      */
  3779.     STARTARGS;
  3780.     SETARG(XmNvisibleItemCount, 3);
  3781.     SETARG(XmNselectionPolicy, XmMULTIPLE_SELECT);
  3782.     SETARG(XmNleftAttachment, XmATTACH_FORM);
  3783.     SETARG(XmNrightAttachment, XmATTACH_FORM);
  3784.     SETARG(XmNtopAttachment, XmATTACH_WIDGET);
  3785.     SETARG(XmNtopWidget, pbp->save_msg_widget);
  3786.     SETARG(XmNbottomAttachment, XmATTACH_FORM);
  3787.     pbp->save_list_widget = XmCreateScrolledList(form, "saveList", ARGLIST);
  3788.     XtManageChild(pbp->save_list_widget);
  3789.  
  3790.     /*
  3791.      * Register callbacks
  3792.      */
  3793.     XtAddCallback(dialog, XmNokCallback, SaveOptionsCB, (XtPointer)pb);
  3794.     XtAddCallback(dialog, XmNapplyCallback, SaveOptionsCB, (XtPointer)pb);
  3795.  
  3796.     return dialog;
  3797. }
  3798.  
  3799.  
  3800. /**************************************************************************
  3801.  *
  3802.  * Function: ClearPrinterOptions
  3803.  *
  3804.  * Description: Deallocates storage for the spooler specific options
  3805.  *    string.
  3806.  *
  3807.  * Parameters: 
  3808.  *    pbp (I) - this widget's instance part
  3809.  *
  3810.  * Return: none
  3811.  *
  3812.  **************************************************************************/
  3813.  
  3814. static void ClearPrinterOptions(PuiPrintBoxPart *pbp)
  3815. {
  3816.     if (pbp->options) {
  3817.     free((char*)pbp->options);
  3818.     pbp->options = NULL;
  3819.     }
  3820. }
  3821.  
  3822.  
  3823. /**************************************************************************
  3824.  *
  3825.  * Function: AddPrinterOptions
  3826.  *
  3827.  * Description: Adds a specified option to the spooler specific options
  3828.  *    string.
  3829.  *
  3830.  * Parameters: 
  3831.  *    pbp (I) - this widget's instance part
  3832.  *    option (I) - option to add to string.
  3833.  *
  3834.  * Return: none
  3835.  *
  3836.  **************************************************************************/
  3837.  
  3838. static void AddPrinterOptions(PuiPrintBoxPart *pbp, char *option)
  3839. {
  3840.     int len;
  3841.  
  3842.     if (!pbp->options)
  3843.     pbp->options = strdup(option);
  3844.     else {
  3845.     len = strlen(pbp->options) + strlen(option) + 5;
  3846.     pbp->options = (char*)realloc(pbp->options, len);
  3847.     (void)strcat(pbp->options, " ");
  3848.     (void)strcat(pbp->options, option);
  3849.     }
  3850. }
  3851.  
  3852.  
  3853. /**************************************************************************
  3854.  *
  3855.  * Function: SetStringValue
  3856.  *
  3857.  * Description: Handles the SetValues method string setting operations.
  3858.  *
  3859.  * Parameters: 
  3860.  *    cstrp (I,O) - current string
  3861.  *    rstrp (I,O) - requested string
  3862.  *    nstrp (I,O) - new string
  3863.  *
  3864.  * Return: none
  3865.  *
  3866.  **************************************************************************/
  3867.  
  3868. static void SetStringValue(char **cstrp, char **rstrp, char **nstrp)
  3869. {
  3870.     if (*nstrp)
  3871.         *nstrp = XtNewString(*nstrp);    
  3872.     XtFree((char*)*cstrp);
  3873.     *cstrp = *rstrp = NULL;
  3874. }
  3875.  
  3876.  
  3877. /**************************************************************************
  3878.  *
  3879.  * Function: DestroyParentCB
  3880.  *
  3881.  * Description: Destroys the parent of a widget. Used by the dialog
  3882.  *    convenience function.
  3883.  *
  3884.  * Parameters: 
  3885.  *    w (I) - invoking widget
  3886.  *    client_data (I) - not used
  3887.  *    call_data (I) - not used
  3888.  *
  3889.  * Return: none
  3890.  *
  3891.  **************************************************************************/
  3892. /* ARGSUSED */
  3893.  
  3894. static void DestroyParentCB(Widget w, XtPointer client_data,
  3895.                     XtPointer call_data)
  3896. {
  3897.     XtDestroyWidget(XtParent(w));
  3898. }
  3899.  
  3900.  
  3901. /**************************************************************************
  3902.  *
  3903.  * Function: UnmanageCB
  3904.  *
  3905.  * Description: Unmanages the printBox if it is a dialog. Invoked if the
  3906.  *    autoUnmanage resource for bulletin board is true.
  3907.  *
  3908.  * Parameters: 
  3909.  *    w (I) - invoking widget
  3910.  *    client_data (I) - widget to unmanage
  3911.  *    call_data (I) - not used
  3912.  *
  3913.  * Return: none
  3914.  *
  3915.  **************************************************************************/
  3916. /* ARGSUSED */
  3917.  
  3918. static void UnmanageCB(Widget w, XtPointer client_data,
  3919.                     XtPointer call_data)
  3920. {
  3921.     XtUnmanageChild((Widget)client_data);
  3922. }
  3923.  
  3924.  
  3925. /**************************************************************************
  3926.  *
  3927.  * Function: SetOptionsSize
  3928.  *
  3929.  * Description: Computes the initial size for the options scrolled window
  3930.  *    so that the window displays all options without the need to scroll.
  3931.  *
  3932.  * Parameters: 
  3933.  *    pbp (I) - this widget's instance part
  3934.  *
  3935.  * Return: none
  3936.  *
  3937.  **************************************************************************/
  3938.  
  3939. static void SetOptionsSize(PuiPrintBoxPart *pbp)
  3940. {
  3941.     int dw, dh;
  3942.     Dimension width, fwidth, fheight;
  3943.     Dimension sb_space, sb_size;
  3944.     Widget sb, cwin;
  3945.     DEFARGS(15);
  3946.  
  3947.     /*
  3948.      * If no option section requested or if the widget is
  3949.      * realized we don't need to calc anything
  3950.      */
  3951.     if (!pbp->res_show_opts || XtIsRealized(pbp->option_form))
  3952.     return;
  3953.  
  3954.     /*
  3955.      * Get the scrolled window clip window and the scrollbar dims
  3956.      */
  3957.     STARTARGS;
  3958.     SETARG(XmNclipWindow, &cwin);
  3959.     SETARG(XmNverticalScrollBar, &sb);
  3960.     SETARG(XmNspacing, &sb_space);
  3961.     XtGetValues(pbp->opts_sw_widget, ARGLIST);
  3962.  
  3963.     /*
  3964.      * Calc space dedicated to scrollbar and size of clip window
  3965.      * versus size of total size of window being viewed
  3966.      */
  3967.     sb_size = WIDTH(sb) + sb_space;
  3968.     if ((dw = WIDTH(pbp->opts_rc_widget) - WIDTH(cwin) - sb_size) < 0)
  3969.     dw = 0;
  3970.     if ((dh = HEIGHT(pbp->opts_rc_widget) - HEIGHT(cwin) - sb_size) < 0)
  3971.     dh = 0;
  3972.     width = WIDTH(pbp->opts_sw_widget) + dw;
  3973.  
  3974.     fwidth = WIDTH(pbp->option_form);
  3975.     fheight = HEIGHT(pbp->option_form);
  3976.  
  3977.     if (width > fwidth)
  3978.         fwidth = width;
  3979.     fheight += dh;
  3980.  
  3981.     XtResizeWidget(pbp->option_form, fwidth, fheight,
  3982.                         BWIDTH(pbp->option_form));
  3983. }
  3984.  
  3985.  
  3986. /**************************************************************************
  3987.  *
  3988.  * Function: SetPrinterListSize
  3989.  *
  3990.  * Description: Computes the initial size for the printer list widget.
  3991.  *
  3992.  * Parameters: 
  3993.  *    pbp (I) - this widget's instance part
  3994.  *
  3995.  * Return: none
  3996.  *
  3997.  **************************************************************************/
  3998.  
  3999. static void SetPrinterListSize(PuiPrintBoxPart *pbp)
  4000. {
  4001.     Dimension sb_space, sb_size;
  4002.     Dimension width;
  4003.     Widget sb;
  4004.     DEFARGS(10);
  4005.  
  4006.     if (XtIsRealized(pbp->pf_form))
  4007.     return;
  4008.  
  4009.     /*
  4010.      * Get the size of the scrollbar and any margin. We
  4011.      * need to do this so that if there is no scrollbar
  4012.      * yet, when we resize and get one we do not obscure
  4013.      * list text
  4014.      */
  4015.     STARTARGS;
  4016.     SETARG(XmNverticalScrollBar, &sb);
  4017.     SETARG(XmNspacing, &sb_space);
  4018.     XtGetValues(XtParent(pbp->plist_widget), ARGLIST);
  4019.     sb_size = WIDTH(sb) + sb_space;
  4020.  
  4021.     /*
  4022.      * Get diemsnions of newly grown list
  4023.      */
  4024.     width = WIDTH(pbp->plist_widget);
  4025.  
  4026.     /*
  4027.      * Based on the presence of a list scrollbar and the width of
  4028.      * the new list calculate what the list should be resized to.
  4029.      * We never want to let the scrolled list width be less than the
  4030.      * filename/printer list form width.
  4031.      */
  4032.     width += sb_size;
  4033.     if (width < WIDTH(pbp->pf_form))
  4034.     width = WIDTH(pbp->pf_form);
  4035.  
  4036.     /*
  4037.      * Set the proper size
  4038.      */
  4039.     XtResizeWidget(pbp->pf_form, width, HEIGHT(pbp->pf_form),
  4040.                             BWIDTH(pbp->pf_form));
  4041. }
  4042.  
  4043.  
  4044. /**************************************************************************
  4045.  *
  4046.  * Function: SetActionAreaSize
  4047.  *
  4048.  * Description: Sets the width of the action form in the case where the
  4049.  *    buttons are to be centered.
  4050.  *
  4051.  * Parameters: 
  4052.  *    pbp (I) - this widget's instance part
  4053.  *
  4054.  * Return: none
  4055.  *
  4056.  **************************************************************************/
  4057.  
  4058. static void SetActionAreaSize(PuiPrintBoxPart *pbp)
  4059. {
  4060.     if (pbp->res_button_placement == PuiBUTTONS_CENTER)
  4061.         XtResizeWidget(pbp->action_form, WIDTH(pbp->action_rc),
  4062.             HEIGHT(pbp->action_form), BWIDTH(pbp->action_form));
  4063. }
  4064.  
  4065.  
  4066. /**************************************************************************
  4067.  *
  4068.  * Function: HandleError
  4069.  *
  4070.  * Description: Processes the detection of a libspool error condition.
  4071.  *    The function creates the appropriate error callback structure and
  4072.  *    calls the functions on the widget's error callback list.
  4073.  *
  4074.  * Parameters:
  4075.  *    pb (I) - this widget
  4076.  *    err_code (I) - SLerrno value
  4077.  *
  4078.  * Return: none
  4079.  *
  4080.  **************************************************************************/
  4081.  
  4082. static void HandleError(PuiPrintBoxWidget pb, int err_code)
  4083. {
  4084.     PuiPrintBoxCallbackStruct pb_cb;
  4085.  
  4086.     InitCallback(&pb_cb);
  4087.     pb_cb.reason = PuiCR_ERROR;
  4088.     pb_cb.error_code = err_code;
  4089.     XtCallCallbackList((Widget)pb, pb->printBox.res_error_callback,
  4090.                             (XtPointer)&pb_cb);
  4091. }
  4092.  
  4093.  
  4094. /**************************************************************************
  4095.  *
  4096.  * Function: InitTextFieldColors
  4097.  *
  4098.  * Description: Sets the instance part fields for text field foreground,
  4099.  *    background and shadow colors for use in settings the text field
  4100.  *    to sensitive and insensitive states. We want to have the text
  4101.  *    field foreground and background color change when the text field
  4102.  *    is made insensitive.
  4103.  *
  4104.  * Parameters: 
  4105.  *    pb (I) - this widget
  4106.  *
  4107.  * Return: none
  4108.  *
  4109.  **************************************************************************/
  4110.  
  4111. static void InitTextFieldColors(PuiPrintBoxWidget pb)
  4112. {
  4113.     PuiPrintBoxPart *pbp = &pb->printBox;
  4114.     register int n;
  4115.     Arg args[5];
  4116.  
  4117.     /*
  4118.      * Get the sensitive foreground and background color of a
  4119.      * representative test field widget, the filename list widget
  4120.      */
  4121.     n = 0;
  4122.     XtSetArg(args[n], XmNforeground, &pbp->tfield_sensitive.foreground); n++;
  4123.     XtSetArg(args[n], XmNbackground, &pbp->tfield_sensitive.background); n++;
  4124.     XtGetValues(pbp->files_widget, args, n);
  4125.  
  4126.     /*
  4127.      * Compute the text field shadow colors
  4128.      * for the sensitive and insensitive states
  4129.      */
  4130.     XmGetColors(XtScreen(pb), pb->core.colormap,
  4131.         pbp->tfield_sensitive.background,
  4132.         NULL,
  4133.         &pbp->tfield_sensitive.tshadow,
  4134.         &pbp->tfield_sensitive.bshadow,
  4135.         NULL);
  4136.     XmGetColors(XtScreen(pb), pb->core.colormap,
  4137.         pbp->tfield_insensitive.background,
  4138.         NULL,
  4139.         &pbp->tfield_insensitive.tshadow,
  4140.         &pbp->tfield_insensitive.bshadow,
  4141.         NULL);
  4142. }
  4143.  
  4144.  
  4145. /**************************************************************************
  4146.  *
  4147.  * Function: SetTextFieldSensitivity
  4148.  *
  4149.  * Description: Sets the sensitivity of the specified text field widget.
  4150.  *    The editability as well as the foreground and background colors
  4151.  *    of the field are changed according to the specified state.
  4152.  *
  4153.  * Parameters: 
  4154.  *    pbp (I) - this widget's instance part
  4155.  *    field (I) - widget ID of text field whose sensitivity is to be
  4156.  *            changed.
  4157.  *    sensitive (I) - True or False.
  4158.  *
  4159.  * Return: none
  4160.  *
  4161.  **************************************************************************/
  4162.  
  4163. static void SetTextFieldSensitivity(PuiPrintBoxPart *pbp, Widget field,
  4164.                     Boolean sensitive)
  4165. {
  4166.     Arg args[10];
  4167.     register int n = 0;
  4168.     PuiPrintBoxFieldColors colors;
  4169.  
  4170.     XtSetArg(args[n], XmNeditable, sensitive); n++;
  4171.     if (sensitive)
  4172.     colors = pbp->tfield_sensitive;
  4173.     else
  4174.     colors = pbp->tfield_insensitive;
  4175.     XtSetArg(args[n], XmNforeground, colors.foreground); n++;
  4176.     XtSetArg(args[n], XmNbackground, colors.background); n++;
  4177.     XtSetArg(args[n], XmNtopShadowColor,colors.tshadow); n++;
  4178.     XtSetArg(args[n], XmNbottomShadowColor, colors.bshadow); n++;
  4179.     XtSetValues(field, args, n);
  4180. }
  4181.  
  4182.  
  4183. /**************************************************************************
  4184.  *
  4185.  * Function: SetCursor
  4186.  *
  4187.  * Description: Sets the cursor to the state specified.
  4188.  *
  4189.  * Parameters:
  4190.  *    pb (I) - this widget
  4191.  *    state (I) - one of PuiCursorBusy or PuiCursorNormal
  4192.  *
  4193.  * Return: none
  4194.  *
  4195.  **************************************************************************/
  4196.  
  4197. static void SetCursor(PuiPrintBoxWidget pb, PuiCursorState state)
  4198. {
  4199.     PuiPrintBoxPart *pbp = &pb->printBox;
  4200.  
  4201.     switch (state) {
  4202.     case PuiCursorBusy:
  4203.         XDefineCursor(XtDisplay((Widget)pb), XtWindow((Widget)pb),
  4204.                             pbp->res_busy_cursor);
  4205.         break;
  4206.     case PuiCursorNormal:
  4207.         XUndefineCursor(XtDisplay((Widget)pb), XtWindow((Widget)pb));
  4208.         break;
  4209.     }
  4210.     XFlush(XtDisplay((Widget)pb));
  4211. }
  4212.  
  4213.  
  4214. /**************************************************************************
  4215.  *
  4216.  * Function: ReadSpoolerOptionsFile
  4217.  *
  4218.  * Description: Reads the spooling system options file, if any, and sets
  4219.  *    the UI accordingly.
  4220.  *
  4221.  * Parameters:
  4222.  *    pbp (I) - this widget's instance part
  4223.  *
  4224.  * Return: none
  4225.  *
  4226.  **************************************************************************/
  4227.  
  4228. static void ReadSpoolerOptionsFile(PuiPrintBoxPart *pbp)
  4229. {
  4230.     SLSysVSpoolerOptionsStruct *spooler_opts;
  4231.  
  4232.     /*
  4233.      * Read the spooler options file
  4234.      */
  4235.     if (SLSysVGetSpoolerOptions(&spooler_opts) < 0)
  4236.     return;
  4237.  
  4238.     /*
  4239.      * Set the UI accordingly
  4240.      */
  4241.     if (spooler_opts->copy) {
  4242.         pbp->res_copy = True;
  4243.         SetOptionJobHandling(pbp);
  4244.     }
  4245.  
  4246.     if (spooler_opts->mail)
  4247.     pbp->res_mail = True;
  4248.     if (spooler_opts->message)
  4249.     pbp->res_message = True;
  4250.     if (spooler_opts->mail || spooler_opts->message)
  4251.         SetOptionCompletion(pbp);
  4252.  
  4253.     if (spooler_opts->title) {
  4254.         if (pbp->res_job_title)
  4255.         XtFree(pbp->res_job_title);
  4256.     pbp->res_job_title = XtNewString(spooler_opts->title);
  4257.         SetOptionBanner(pbp);
  4258.     }
  4259. }
  4260.  
  4261.  
  4262. /**************************************************************************
  4263.  *
  4264.  * Function: WriteSpoolerOptionsFile
  4265.  *
  4266.  * Description: Writes the spooler options file based on the state of
  4267.  *    the PrintBox UI.
  4268.  *
  4269.  * Parameters: 
  4270.  *    pb (I) - this widget
  4271.  *
  4272.  * Return: 0 if success and -1 if failure.
  4273.  *
  4274.  **************************************************************************/
  4275.  
  4276. static int WriteSpoolerOptionsFile(PuiPrintBoxWidget pb)
  4277. {
  4278.     PuiPrintBoxPart *pbp = &pb->printBox;
  4279.     SLSysVSpoolerOptionsStruct spooler_opts;
  4280.     XtArgVal val;
  4281.     int retv;
  4282.  
  4283.     /*
  4284.      * Fill in the spooler options struct from the UI.
  4285.      *
  4286.      * Note that we do not care about the number of copies.
  4287.      * The number of copies would cause more harm than good if it were
  4288.      * placed in the rc file. Accidently setting 500 copies could have
  4289.      * interesting results for future print jobs. We also do not write
  4290.      * the printer name since this would raise confusion between the
  4291.      * system default printer and the glprc printer.
  4292.      */
  4293.     SynthGetOptionJobHandling((Widget)pb, offset(printBox.res_copy), &val);
  4294.     spooler_opts.copy = (val)? 1: 0;
  4295.  
  4296.     SynthGetOptionCompletion((Widget)pb, offset(printBox.res_mail), &val);
  4297.     spooler_opts.mail = (val)? 1: 0;
  4298.  
  4299.     SynthGetOptionCompletion((Widget)pb, offset(printBox.res_message), &val);
  4300.     spooler_opts.message = (val)? 1: 0;
  4301.  
  4302.     SynthGetOptionBanner((Widget)pb, offset(printBox.res_job_title), &val);
  4303.     spooler_opts.title = (char*)val;
  4304.  
  4305.     spooler_opts.suppress_id = 0;    /* Not supported at widget level */
  4306.  
  4307.     /*
  4308.      * Write the file
  4309.      */
  4310.     retv = SLSysVSaveSpoolerOptions(&spooler_opts);
  4311.  
  4312.     /*
  4313.      * Free any allocated storage
  4314.      */
  4315.     if (spooler_opts.title)
  4316.     XtFree(spooler_opts.title);
  4317.  
  4318.     return retv;
  4319. }
  4320.  
  4321.  
  4322. /**************************************************************************
  4323.  *
  4324.  * Function: ReadPrinterOptionsFile
  4325.  *
  4326.  * Description: Reads the printer specific options, if any, for the
  4327.  *    specified printer
  4328.  *
  4329.  * Parameters: 
  4330.  *    printer_name (I) - name of printer whose options are desired
  4331.  *
  4332.  * Return: Printer specific option string or empty string "" if no printer
  4333.  *    options found. It is the caller's responsibility to free the
  4334.  *    storage allocated by this function.
  4335.  *
  4336.  **************************************************************************/
  4337.  
  4338. static char* ReadPrinterOptionsFile(char *printer_name)
  4339. {
  4340.     char *option_str;
  4341.  
  4342.     if (SLSysVGetPrinterOptions(printer_name, &option_str) < 0 ||
  4343.                 option_str == NULL)
  4344.     return XtNewString("");
  4345.     return XtNewString(option_str);
  4346. }
  4347.  
  4348.  
  4349. /**************************************************************************
  4350.  *
  4351.  * Function: WritePrinterOptionsFile
  4352.  *
  4353.  * Description: Writes the printer specific option file for the specified
  4354.  *    printer.
  4355.  *
  4356.  * Parameters: 
  4357.  *    printer_name (I) - name of printer whose options are to be saved.
  4358.  *    option_str (I) - printer specific option string.
  4359.  *    save_type (I) - what type of options to save (i.e. SL_SAVE_USER or
  4360.  *            SL_SAVE_DEFAULT).
  4361.  *
  4362.  * Return: 0 if successfull, -1 if not.
  4363.  *
  4364.  **************************************************************************/
  4365.  
  4366. static int WritePrinterOptionsFile(char *printer_name, char *option_str,
  4367.                     int save_type)
  4368. {
  4369.     return SLSysVSavePrinterOptions(printer_name, option_str, save_type);
  4370. }
  4371.  
  4372.  
  4373. /**************************************************************************
  4374.  *
  4375.  * Function: UpdatePrinterOption
  4376.  *
  4377.  * Description: Reads the printer options type-in on the PrintBox UI
  4378.  *    and compares it to the specified printer option string. If
  4379.  *    the two differ, the printer option structure is updated to reflect
  4380.  *    the UI and is marked as modified.
  4381.  *
  4382.  * Parameters: 
  4383.  *    pb (I) - this widget
  4384.  *    option_ptr (I) - printer options structure
  4385.  *
  4386.  * Return: none
  4387.  *
  4388.  **************************************************************************/
  4389.  
  4390. static void UpdatePrinterOption(PuiPrintBoxWidget pb,
  4391.                     PuiPrinterOption *option_ptr)
  4392. {
  4393.     XtArgVal val;
  4394.  
  4395.     /*
  4396.      * Get the printer specific options string from the UI
  4397.      */
  4398.     SynthGetOptionPrinterSpecific((Widget)pb, offset(printBox.res_spec_opts),
  4399.                             &val);
  4400.  
  4401.     /*
  4402.      * Compare the option strings and update if necessary
  4403.      */
  4404.     if (strcmp((char*)val, option_ptr->option_str)) {
  4405.     XtFree(option_ptr->option_str);
  4406.     option_ptr->option_str = XtNewString((char*)val);
  4407.     option_ptr->modified = True;
  4408.     }
  4409.     
  4410.     /*
  4411.      * Clean up
  4412.      */
  4413.     XtFree((char*)val);
  4414. }
  4415.  
  4416.  
  4417. /**************************************************************************
  4418.  *
  4419.  * Function: InitCallback
  4420.  *
  4421.  * Description: Initializes a callback structure. All fields of the
  4422.  *    callback structure are set to default values. This way the caller
  4423.  *    need only set the fields of interest after calling this function.
  4424.  *
  4425.  * Parameters: 
  4426.  *    cb (I) - pointer to a callback struct
  4427.  *
  4428.  * Return: none
  4429.  *
  4430.  **************************************************************************/
  4431.  
  4432. static void InitCallback(PuiPrintBoxCallbackStruct *cb)
  4433. {
  4434.     cb->reason = PuiCR_NOREASON;
  4435.     cb->event = NULL;
  4436.     cb->job_info = NULL;
  4437.     cb->selected_printer = NULL;
  4438.     cb->selected_position = 0;
  4439.     cb->error_code = 0;
  4440. }
  4441.  
  4442.  
  4443. /*
  4444.  ==========================================================================
  4445.             SYNTHETIC RESOURCE FUNCTIONS
  4446.  ==========================================================================
  4447. */
  4448.  
  4449.  
  4450. /**************************************************************************
  4451.  *
  4452.  * Function: SynthGetFilename
  4453.  *
  4454.  * Description: Synthetic resource function for getting the filename value
  4455.  *    from the UI.
  4456.  *
  4457.  * Parameters: 
  4458.  *    w (I) - this widget
  4459.  *    resource_offset (I) - offset of value in instance part
  4460.  *    valuep (O) - value to return
  4461.  *
  4462.  * Return: none
  4463.  *
  4464.  **************************************************************************/
  4465. /* ARGSUSED */
  4466.  
  4467. static void SynthGetFilename(Widget w, int resource_offset,
  4468.                             XtArgVal *valuep)
  4469. {
  4470.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4471.  
  4472.     *valuep = (XtArgVal)XmTextFieldGetString(pbp->files_widget);
  4473. }
  4474.  
  4475.  
  4476. /**************************************************************************
  4477.  *
  4478.  * Function: SynthGetPrinter
  4479.  *
  4480.  * Description: Synthetic resource function for getting the selected
  4481.  *    printer from the UI.
  4482.  *
  4483.  * Parameters: 
  4484.  *    w (I) - this widget
  4485.  *    resource_offset (I) - offset of value in instance part
  4486.  *    valuep (O) - value to return
  4487.  *
  4488.  * Return: none
  4489.  *
  4490.  **************************************************************************/
  4491. /* ARGSUSED */
  4492.  
  4493. static void SynthGetPrinter(Widget w, int resource_offset,
  4494.                             XtArgVal *valuep)
  4495. {
  4496.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4497.  
  4498.     if (pbp->res_printer) {
  4499.     XtFree((char*)pbp->res_printer);
  4500.     pbp->res_printer = NULL;
  4501.     }
  4502.     if (pbp->selected_printer_index >= 0)
  4503.     pbp->res_printer =
  4504.         XtNewString(
  4505.             pbp->res_printer_list[pbp->selected_printer_index].local_name);
  4506.     *valuep = (XtArgVal)pbp->res_printer;
  4507. }
  4508.  
  4509.  
  4510. /**************************************************************************
  4511.  *
  4512.  * Function: SynthGetButtonSpacing
  4513.  *
  4514.  * Description: Synthetic resource function for getting the action area
  4515.  *    button spacing from the row column.
  4516.  *
  4517.  * Parameters: 
  4518.  *    w (I) - this widget
  4519.  *    resource_offset (I) - offset of value in instance part
  4520.  *    valuep (O) - value to return
  4521.  *
  4522.  * Return: none
  4523.  *
  4524.  **************************************************************************/
  4525. /* ARGSUSED */
  4526.  
  4527. static void SynthGetButtonSpacing(Widget w, int resource_offset,
  4528.                             XtArgVal *valuep)
  4529. {
  4530.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4531.     Dimension spacing;
  4532.     Arg arg;
  4533.  
  4534.     XtSetArg(arg, XmNspacing, &spacing);
  4535.     XtGetValues(pbp->action_rc, &arg, 1);
  4536.     *valuep = (XtArgVal)spacing;
  4537. }
  4538.  
  4539.  
  4540. /**************************************************************************
  4541.  *
  4542.  * Function: SynthGetVisibleCount
  4543.  *
  4544.  * Description: Synthetic resource function for getting the visible item
  4545.  *    count from the printer list.
  4546.  *
  4547.  * Parameters: 
  4548.  *    w (I) - this widget
  4549.  *    resource_offset (I) - offset of value in instance part
  4550.  *    valuep (O) - value to return
  4551.  *
  4552.  * Return: none
  4553.  *
  4554.  **************************************************************************/
  4555. /* ARGSUSED */
  4556.  
  4557. static void SynthGetVisibleCount(Widget w, int resource_offset,
  4558.                             XtArgVal *valuep)
  4559. {
  4560.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4561.     Arg arg;
  4562.  
  4563.     XtSetArg(arg, XmNvisibleItemCount, valuep);
  4564.     XtGetValues(pbp->plist_widget, &arg, 1);
  4565. }
  4566.  
  4567.  
  4568. /**************************************************************************
  4569.  *
  4570.  * Function: SynthGetLabel
  4571.  *
  4572.  * Description: Synthetic resource function for getting the labels
  4573.  *    of various UI child components directly from the component.
  4574.  *
  4575.  * Parameters: 
  4576.  *    w (I) - this widget
  4577.  *    resource_offset (I) - offset of value in instance part
  4578.  *    valuep (O) - value to return
  4579.  *
  4580.  * Return: none
  4581.  *
  4582.  **************************************************************************/
  4583.  
  4584. static void SynthGetLabel(Widget w, int resource_offset, XtArgVal *valuep)
  4585. {
  4586.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4587.     String res_name = XmNlabelString;
  4588.     Widget label_widget;
  4589.  
  4590.     /*
  4591.      * Based on the resource querried get the appropriate label
  4592.      * widget
  4593.      */
  4594.     switch (resource_offset) {
  4595.     case offset(printBox.res_printb_label):
  4596.             label_widget = pbp->printb_widget;
  4597.         break;
  4598.     case offset(printBox.res_user1b_label):
  4599.             label_widget = pbp->user1b_widget;
  4600.         break;
  4601.     case offset(printBox.res_user2b_label):
  4602.             label_widget = pbp->user2b_widget;
  4603.         break;
  4604.     case offset(printBox.res_user3b_label):
  4605.             label_widget = pbp->user3b_widget;
  4606.         break;
  4607.     case offset(printBox.res_user4b_label):
  4608.             label_widget = pbp->user4b_widget;
  4609.         break;
  4610.     case offset(printBox.res_optionsb_label):
  4611.             label_widget = pbp->optionsb_widget;
  4612.         break;
  4613.     case offset(printBox.res_saveb_label):
  4614.             label_widget = pbp->saveb_widget;
  4615.         break;
  4616.     case offset(printBox.res_cancelb_label):
  4617.             label_widget = pbp->cancelb_widget;
  4618.         break;
  4619.     case offset(printBox.res_helpb_label):
  4620.             label_widget = pbp->helpb_widget;
  4621.         break;
  4622.     case offset(printBox.res_files_label):
  4623.             label_widget = pbp->files_label_widget;
  4624.         break;
  4625.     case offset(printBox.res_plist_label):
  4626.             label_widget = pbp->plist_label_widget;
  4627.         break;
  4628.     case offset(printBox.res_opts_label):
  4629.             label_widget = pbp->opts_label_widget;
  4630.         break;
  4631.     case offset(printBox.res_numcopies_label):
  4632.         label_widget = pbp->numcopies_label_widget;
  4633.         break;
  4634.     case offset(printBox.res_title_label):
  4635.         label_widget = pbp->title_label_widget;
  4636.         break;
  4637.     case offset(printBox.res_deftitle_label):
  4638.         label_widget = pbp->banner_deftitle_widget;
  4639.         break;
  4640.     case offset(printBox.res_spectitle_label):
  4641.         label_widget = pbp->banner_spectitle_widget;
  4642.         break;
  4643.     case offset(printBox.res_complete_label):
  4644.         label_widget = pbp->complete_label_widget;
  4645.         break;
  4646.     case offset(printBox.res_complete_mail_label):
  4647.         label_widget = pbp->complete_mail_widget;
  4648.         break;
  4649.     case offset(printBox.res_complete_mess_label):
  4650.         label_widget = pbp->complete_mess_widget;
  4651.         break;
  4652.     case offset(printBox.res_handling_label):
  4653.         label_widget = pbp->handling_label_widget;
  4654.         break;
  4655.     case offset(printBox.res_handling_copy_label):
  4656.         label_widget = pbp->handling_copy_widget;
  4657.         break;
  4658.     case offset(printBox.res_handling_link_label):
  4659.         label_widget = pbp->handling_link_widget;
  4660.         break;
  4661.     case offset(printBox.res_spec_options_label):
  4662.         label_widget = pbp->spec_options_label_widget;
  4663.         break;
  4664.     case offset(printBox.res_savedlg_title_label):
  4665.         label_widget = pbp->save_dialog_widget;
  4666.         res_name = XmNdialogTitle;
  4667.         break;
  4668.     case offset(printBox.res_savedlg_saveb_label):
  4669.         label_widget = pbp->save_dialog_widget;
  4670.         res_name = XmNokLabelString;
  4671.         break;
  4672.     case offset(printBox.res_savedlg_userb_label):
  4673.         label_widget = pbp->save_dialog_widget;
  4674.         res_name = XmNokLabelString;
  4675.         break;
  4676.     case offset(printBox.res_savedlg_allb_label):
  4677.         label_widget = pbp->save_dialog_widget;
  4678.         res_name = XmNcancelLabelString;
  4679.         break;
  4680.     case offset(printBox.res_savedlg_cancelb_label):
  4681.         label_widget = pbp->save_dialog_widget;
  4682.         res_name = XmNhelpLabelString;
  4683.         break;
  4684.     case offset(printBox.res_savedlg_msg_label):
  4685.         label_widget = pbp->save_msg_widget;
  4686.         break;
  4687.     default:
  4688.         label_widget = NULL;
  4689.         break;
  4690.     }
  4691.  
  4692.     /*
  4693.      * Get the widget label string
  4694.      */
  4695.     if (label_widget) {
  4696.     Arg arg;
  4697.         XtSetArg(arg, res_name, valuep);
  4698.     XtGetValues(label_widget, &arg, 1);
  4699.     } else
  4700.     *valuep = NULL;
  4701. }
  4702.  
  4703.  
  4704. /*
  4705.  ==========================================================================
  4706.             PRINTING OPTION FUNCTIONS
  4707.  ==========================================================================
  4708. */
  4709.  
  4710.  
  4711. /*
  4712.  --------------------------------------------------------------------------
  4713.             Number Of Copies
  4714.  --------------------------------------------------------------------------
  4715. */
  4716.  
  4717.  
  4718. static void option_numcopies_val_cb(Widget, XtPointer, XtPointer);
  4719. static void option_numcopies_ud_cb(Widget, XtPointer, XtPointer);
  4720.  
  4721.  
  4722. /**************************************************************************
  4723.  *
  4724.  * Function: CreateOptionNumCopies
  4725.  *
  4726.  * Description: Create the number of copies option components
  4727.  *
  4728.  * Parameters: 
  4729.  *    pbp (I) - this widget's instance part
  4730.  *    parent (I) - parent widget ID
  4731.  *
  4732.  * Return: none
  4733.  *
  4734.  **************************************************************************/
  4735.  
  4736. static void CreateOptionNumCopies(PuiPrintBoxPart *pbp, Widget parent)
  4737. {
  4738.     Widget rc, inc_widget, dec_widget;
  4739.     DEFARGS(15);
  4740.  
  4741.     /*
  4742.      * Create a horixontal RowColumn to hold the label and
  4743.      * text field
  4744.      */
  4745.     STARTARGS;
  4746.     SETARG(XmNorientation, XmHORIZONTAL);
  4747.     SETARG(XmNpacking, XmPACK_TIGHT);
  4748.     SETARG(XmNspacing, LABEL_FIELD_SPACE);
  4749.     rc = XtCreateWidget("numCopiesRowC", xmRowColumnWidgetClass,
  4750.                     parent, ARGLIST);
  4751.     if (pbp->res_show_numcopies)
  4752.     XtManageChild(rc);
  4753.  
  4754.     /*
  4755.      * Create the field label
  4756.      */
  4757.     STARTARGS;
  4758.     SETARG(XmNlabelString, pbp->res_numcopies_label);
  4759.     pbp->numcopies_label_widget = XtCreateManagedWidget(DEF_NUMCOPIES_LABEL,
  4760.                      xmLabelWidgetClass,
  4761.                     rc, ARGLIST);
  4762.  
  4763.     /*
  4764.      * Create the field
  4765.      */
  4766.     STARTARGS;
  4767.     SETARG(XmNcolumns, NUM_COPIES_COLS);
  4768.     SETARG(XmNmarginHeight, TEXT_FIELD_MAR);
  4769.     SETARG(XmNmarginWidth, TEXT_FIELD_MAR);
  4770.     pbp->numcopies_text_widget = XtCreateManagedWidget("numCopiesText",
  4771.                     xmTextFieldWidgetClass,
  4772.                     rc, ARGLIST);
  4773.  
  4774.     /*
  4775.      * Create the increment and decrement buttons
  4776.      */
  4777.     STARTARGS;
  4778.     SETARG(XmNwidth, ARROW_WIDTH);
  4779.     SETARG(XmNuserData, (XtPointer)1);
  4780.     SETARG(XmNarrowDirection, XmARROW_UP);
  4781.     inc_widget = XtCreateManagedWidget("incButton",
  4782.                     xmArrowButtonWidgetClass,
  4783.                     rc, ARGLIST);
  4784.     STARTARGS;
  4785.     SETARG(XmNwidth, ARROW_WIDTH);
  4786.     SETARG(XmNuserData, (XtPointer)-1);
  4787.     SETARG(XmNarrowDirection, XmARROW_DOWN);
  4788.     dec_widget = XtCreateManagedWidget("decButton",
  4789.                     xmArrowButtonWidgetClass,
  4790.                     rc, ARGLIST);
  4791.  
  4792.     /*
  4793.      * Register the text field modify callback
  4794.      */
  4795.     XtAddCallback(pbp->numcopies_text_widget, XmNmodifyVerifyCallback,
  4796.                 option_numcopies_val_cb, (XtPointer)pbp);
  4797.  
  4798.     /*
  4799.      * Register the increment/decrement button callbacks
  4800.      */
  4801.     XtAddCallback(inc_widget, XmNactivateCallback, option_numcopies_ud_cb,
  4802.                 (XtPointer)pbp);
  4803.     XtAddCallback(dec_widget, XmNactivateCallback, option_numcopies_ud_cb,
  4804.                 (XtPointer)pbp);
  4805. }
  4806.  
  4807.  
  4808. /**************************************************************************
  4809.  *
  4810.  * Function: SetOptionNumCopies
  4811.  *
  4812.  * Description: Sets the number of copies option based on the resource
  4813.  *
  4814.  * Parameters:
  4815.  *    pbp (I) - this widget's instance part
  4816.  *
  4817.  * Return: none
  4818.  *
  4819.  **************************************************************************/
  4820.  
  4821. static void SetOptionNumCopies(PuiPrintBoxPart *pbp)
  4822. {
  4823.     char buf[50];
  4824.  
  4825.     (void)sprintf(buf, "%d", pbp->res_numcopies);
  4826.     XmTextFieldSetString(pbp->numcopies_text_widget, buf);
  4827. }
  4828.  
  4829.  
  4830. /**************************************************************************
  4831.  *
  4832.  * Function: GetOptionNumCopies
  4833.  *
  4834.  * Description: Gets the print parameter for the number of copies option
  4835.  *
  4836.  * Parameters:
  4837.  *    pbp (I) - this widget's instance part
  4838.  *
  4839.  * Return: none
  4840.  *
  4841.  **************************************************************************/
  4842.  
  4843. static void GetOptionNumCopies(PuiPrintBoxPart *pbp)
  4844. {
  4845.     char *str;
  4846.  
  4847.     str = XmTextFieldGetString(pbp->numcopies_text_widget);
  4848.     if ((pbp->num_copies = atoi(str)) <= 0) {
  4849.         pbp->num_copies = 1;
  4850.         XmTextFieldSetString(pbp->numcopies_text_widget, "1");
  4851.     }
  4852.     XtFree((char*)str);
  4853. }
  4854.  
  4855.  
  4856. /**************************************************************************
  4857.  *
  4858.  * Function: SynthGetOptionNumCopies
  4859.  *
  4860.  * Description: Updates the number of copies resource based on the state of
  4861.  *    the UI.
  4862.  *
  4863.  * Parameters:
  4864.  *    w (I) - this widget
  4865.  *    resource_offset (I) - offset of value in instance part
  4866.  *    valuep (O) - value to return
  4867.  *
  4868.  * Return: none
  4869.  *
  4870.  **************************************************************************/
  4871. /* ARGSUSED */
  4872.  
  4873. static void SynthGetOptionNumCopies(Widget w, int resource_offset,
  4874.                             XtArgVal *valuep)
  4875. {
  4876.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  4877.     char *str;
  4878.     int num;
  4879.  
  4880.     str = XmTextFieldGetString(pbp->numcopies_text_widget);
  4881.     if ((num = atoi(str)) <= 0) {
  4882.     num = 1;
  4883.         XmTextFieldSetString(pbp->numcopies_text_widget, "1");
  4884.     }
  4885.     XtFree((char*)str);
  4886.     *valuep = (XtArgVal)num;
  4887. }
  4888.  
  4889.  
  4890. /**************************************************************************
  4891.  *
  4892.  * Function: option_numcopies_val_cb
  4893.  *
  4894.  * Description: Called whenever the number of copies text field value is
  4895.  *    modified. This routine only allows decimal digits to be typed
  4896.  *    into the text field.
  4897.  *
  4898.  * Parameters: 
  4899.  *    w (I) - widget that invoked callback
  4900.  *    client_data (I) - this widget's instance part
  4901.  *    call_data (I) - text field verify callback struct
  4902.  *
  4903.  * Return: none
  4904.  *
  4905.  **************************************************************************/
  4906. /* ARGSUSED */
  4907.  
  4908. static void option_numcopies_val_cb(Widget w, XtPointer client_data,
  4909.                 XtPointer call_data)
  4910. {
  4911.     int i;
  4912.     XmTextVerifyCallbackStruct *cb = (XmTextVerifyCallbackStruct*)call_data;
  4913.  
  4914.     cb->doit = True;
  4915.  
  4916.     if (cb->text->ptr == NULL || cb->text->length == 0) {
  4917.     cb->text->ptr = XtNewString("");
  4918.     return;
  4919.     }
  4920.  
  4921.     for (i = 0; i < cb->text->length; i++) {
  4922.     if (!isdigit((int)cb->text->ptr[i])) {
  4923.         cb->doit = False;
  4924.         break;
  4925.     }
  4926.     }
  4927. }
  4928.  
  4929.  
  4930. /**************************************************************************
  4931.  *
  4932.  * Function: option_numcopies_ud_cb
  4933.  *
  4934.  * Description: Called whenever the increment or decrement buttons are
  4935.  *    activated. The buttons increment or decrement the value in the
  4936.  *    number of copies text field.
  4937.  *
  4938.  * Parameters: 
  4939.  *    w (I) - widget that invoked callback
  4940.  *    client_data (I) - this widget's instance part
  4941.  *    call_data (I) - not used
  4942.  *
  4943.  * Return: none
  4944.  *
  4945.  **************************************************************************/
  4946. /* ARGSUSED */
  4947.  
  4948. static void option_numcopies_ud_cb(Widget w, XtPointer client_data,
  4949.                 XtPointer call_data)
  4950. {
  4951.     PuiPrintBoxPart *pbp = (PuiPrintBoxPart*)client_data;
  4952.     char *str, buf[NUM_COPIES_COLS + 5];
  4953.     int direction, num;
  4954.     DEFARGS(5);
  4955.  
  4956.     /*
  4957.      * Get the button direction - add or subtract
  4958.      */
  4959.     STARTARGS;
  4960.     SETARG(XmNuserData, &direction);
  4961.     XtGetValues(w, ARGLIST);
  4962.  
  4963.     /*
  4964.      * Change the text field value if appropriate
  4965.      */
  4966.     str = XmTextFieldGetString(pbp->numcopies_text_widget);
  4967.     if ((num = atoi(str) + direction) <= 0)
  4968.     num = 1;
  4969.     XtFree((char*)str);
  4970.     (void)sprintf(buf, "%d", num);
  4971.     XmTextFieldSetString(pbp->numcopies_text_widget, buf);
  4972. }
  4973.  
  4974.  
  4975. /*
  4976.  --------------------------------------------------------------------------
  4977.             Banner Page
  4978.  --------------------------------------------------------------------------
  4979. */
  4980.  
  4981.  
  4982. static void option_banner_text_cb(Widget, XtPointer, XtPointer);
  4983.  
  4984.  
  4985. /**************************************************************************
  4986.  *
  4987.  * Function: CreateOptionBanner
  4988.  *
  4989.  * Description: Create the banner page options
  4990.  *
  4991.  * Parameters: 
  4992.  *    pbp (I) - this widget's instance part
  4993.  *    parent (I) - parent widget ID
  4994.  *
  4995.  * Return: none
  4996.  *
  4997.  **************************************************************************/
  4998.  
  4999. static void CreateOptionBanner(PuiPrintBoxPart *pbp, Widget parent)
  5000. {
  5001.     Widget rc, bb;
  5002.     DEFARGS(15);
  5003.  
  5004.     /*
  5005.      * Create a vertical RowColumn to hold everything
  5006.      */
  5007.     STARTARGS;
  5008.     SETARG(XmNorientation, XmVERTICAL);
  5009.     SETARG(XmNpacking, XmPACK_TIGHT);
  5010.     rc = XtCreateWidget("bannerRowC", xmRowColumnWidgetClass,
  5011.                     parent, ARGLIST);
  5012.     if (pbp->res_show_bannertitle)
  5013.     XtManageChild(rc);
  5014.  
  5015.     /*
  5016.      * Create the banner page printing button
  5017.      */
  5018.     STARTARGS;
  5019.     SETARG(XmNlabelString, pbp->res_title_label);
  5020.     pbp->title_label_widget = XtCreateManagedWidget(DEF_JOBTITLE_LABEL,
  5021.                      xmLabelWidgetClass, rc, ARGLIST);
  5022.  
  5023.     /*
  5024.      * Create the title selection buttons
  5025.      */
  5026.     STARTARGS;
  5027.     SETARG(XmNmarginHeight, 0);
  5028.     SETARG(XmNmarginWidth, 0);
  5029.     bb = XtCreateManagedWidget("bannerRadioBB", xmBulletinBoardWidgetClass,
  5030.                     rc, ARGLIST);
  5031.     STARTARGS;
  5032.     SETARG(XmNx, OPTS_INDENT);
  5033.     SETARG(XmNmarginHeight, 0);
  5034.     SETARG(XmNmarginWidth, 0);
  5035.     SETARG(XmNspacing, 0);
  5036.     pbp->banner_select_widget = XmCreateRadioBox(bb, "bannerRadio", ARGLIST);
  5037.     XtManageChild(pbp->banner_select_widget);
  5038.  
  5039.     STARTARGS;
  5040.     SETARG(XmNlabelString, pbp->res_deftitle_label);
  5041.     SETARG(XmNmarginHeight, 0);
  5042.     SETARG(XmNmarginWidth, 0);
  5043.     pbp->banner_deftitle_widget = XtCreateManagedWidget(DEF_DEFTITLE_LABEL,
  5044.                     xmToggleButtonWidgetClass,
  5045.                     pbp->banner_select_widget, ARGLIST);
  5046.  
  5047.     STARTARGS;
  5048.     SETARG(XmNlabelString, pbp->res_spectitle_label);
  5049.     SETARG(XmNmarginHeight, 0);
  5050.     SETARG(XmNmarginWidth, 0);
  5051.     pbp->banner_spectitle_widget = XtCreateManagedWidget(DEF_SPECTITLE_LABEL,
  5052.                     xmToggleButtonWidgetClass,
  5053.                     pbp->banner_select_widget, ARGLIST);
  5054.  
  5055.     /*
  5056.      * Create the title specification text field
  5057.      */
  5058.     STARTARGS;
  5059.     SETARG(XmNx, OPTS_INDENT + WIDTH(pbp->banner_spectitle_widget) +
  5060.                             LABEL_FIELD_SPACE);
  5061.     SETARG(XmNy, HEIGHT(pbp->banner_spectitle_widget));
  5062.     SETARG(XmNcolumns, JOB_TITLE_COLS);
  5063.     SETARG(XmNmarginHeight, TEXT_FIELD_MAR);
  5064.     SETARG(XmNmarginWidth, TEXT_FIELD_MAR);
  5065.     pbp->banner_text_widget = XtCreateManagedWidget("bannerText",
  5066.                     xmTextFieldWidgetClass,
  5067.                     bb, ARGLIST);
  5068.  
  5069.     /*
  5070.      * Register the text field modify callback
  5071.      */
  5072.     XtAddCallback(pbp->banner_text_widget, XmNvalueChangedCallback,
  5073.                 option_banner_text_cb, (XtPointer)pbp);
  5074. }
  5075.  
  5076.  
  5077. /**************************************************************************
  5078.  *
  5079.  * Function: SetOptionBanner
  5080.  *
  5081.  * Description: Sets the banner page option based on the resource
  5082.  *
  5083.  * Parameters:
  5084.  *    pbp (I) - this widget's instance part
  5085.  *
  5086.  * Return: none
  5087.  *
  5088.  **************************************************************************/
  5089.  
  5090. static void SetOptionBanner(PuiPrintBoxPart *pbp)
  5091. {
  5092.     if (pbp->res_job_title)
  5093.         XmTextFieldSetString(pbp->banner_text_widget, pbp->res_job_title);
  5094.     else {
  5095.         XmToggleButtonSetState(pbp->banner_deftitle_widget, True, True);
  5096.         XmToggleButtonSetState(pbp->banner_spectitle_widget, False, True);
  5097.     }
  5098. }
  5099.  
  5100.  
  5101. /**************************************************************************
  5102.  *
  5103.  * Function: GetOptionBanner
  5104.  *
  5105.  * Description: Gets the print parameter for the banner page option
  5106.  *
  5107.  * Parameters:
  5108.  *    pbp (I) - this widget's instance part
  5109.  *
  5110.  * Return: none
  5111.  *
  5112.  **************************************************************************/
  5113.  
  5114. static void GetOptionBanner(PuiPrintBoxPart *pbp)
  5115. {
  5116.     char *str;
  5117.  
  5118.     /*
  5119.      * Clear any previous title
  5120.      */
  5121.     if (pbp->job_title) {
  5122.         free((char*)pbp->job_title);
  5123.         pbp->job_title = NULL;
  5124.     }
  5125.  
  5126.     /*
  5127.      * Return banner page title if one has been specified
  5128.      */
  5129.     if (!XmToggleButtonGetState(pbp->banner_deftitle_widget)) {
  5130.         str = XmTextFieldGetString(pbp->banner_text_widget);
  5131.     pbp->job_title = strdup(str);
  5132.         XtFree((char*)str);
  5133.     }
  5134. }
  5135.  
  5136.  
  5137. /**************************************************************************
  5138.  *
  5139.  * Function: SynthGetOptionBanner
  5140.  *
  5141.  * Description: Updates the banner page option resources based on the
  5142.  *    state of the UI.
  5143.  *
  5144.  * Parameters:
  5145.  *    w (I) - this widget
  5146.  *    resource_offset (I) - offset of value in instance part
  5147.  *    valuep (O) - value to return
  5148.  *
  5149.  * Return: none
  5150.  *
  5151.  **************************************************************************/
  5152. /* ARGSUSED */
  5153.  
  5154. static void SynthGetOptionBanner(Widget w, int resource_offset,
  5155.                             XtArgVal *valuep)
  5156. {
  5157.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  5158.  
  5159.     /*
  5160.      * Get banner page title
  5161.      */
  5162.     if (!XmToggleButtonGetState(pbp->banner_deftitle_widget))
  5163.         *valuep = (XtArgVal)XmTextFieldGetString(pbp->banner_text_widget);
  5164.     else
  5165.         *valuep = (XtArgVal)NULL;
  5166. }
  5167.  
  5168.  
  5169. /**************************************************************************
  5170.  *
  5171.  * Function: option_banner_text_cb
  5172.  *
  5173.  * Description: Callback for setting the title selection toggle buttons
  5174.  *    to user specified title when the title text field is typed-in.
  5175.  *    The object here is that when a user types in the banner page title
  5176.  *    text field, we can assume that they want this title printed on
  5177.  *    the banner page. Therefore, let's help the user and set the toggle
  5178.  *    buttons to select the user specified title automatically when
  5179.  *    he types in the text field.
  5180.  *
  5181.  * Parameters: 
  5182.  *    w (I) - widget that invoked callback
  5183.  *    client_data (I) - this widget's instance part
  5184.  *    call_data (I) - toggle button callback struct
  5185.  *
  5186.  * Return: none
  5187.  *
  5188.  **************************************************************************/
  5189. /* ARGSUSED */
  5190.  
  5191. static void option_banner_text_cb(Widget w, XtPointer client_data,
  5192.                         XtPointer call_data)
  5193. {
  5194.     PuiPrintBoxPart *pbp = (PuiPrintBoxPart*)client_data;
  5195.  
  5196.     XmToggleButtonSetState(pbp->banner_deftitle_widget, False, True);
  5197.     XmToggleButtonSetState(pbp->banner_spectitle_widget, True, True);
  5198. }
  5199.  
  5200.  
  5201. /*
  5202.  --------------------------------------------------------------------------
  5203.             Job Completion Notification
  5204.  --------------------------------------------------------------------------
  5205. */
  5206.  
  5207.  
  5208. /**************************************************************************
  5209.  *
  5210.  * Function: CreateOptionCompletion
  5211.  *
  5212.  * Description: Create the job completion notification option
  5213.  *
  5214.  * Parameters: 
  5215.  *    pbp (I) - this widget's instance part
  5216.  *    parent (I) - parent widget ID
  5217.  *
  5218.  * Return: none
  5219.  *
  5220.  **************************************************************************/
  5221. /* ARGSUSED */
  5222.  
  5223. static void CreateOptionCompletion(PuiPrintBoxPart *pbp, Widget parent)
  5224. {
  5225.     Widget widget, rc, bb;
  5226.     DEFARGS(15);
  5227.  
  5228.     /*
  5229.      * Create a vertical RowColumn to put everything in
  5230.      */
  5231.     STARTARGS;
  5232.     SETARG(XmNorientation, XmVERTICAL);
  5233.     SETARG(XmNpacking, XmPACK_TIGHT);
  5234.     rc = XtCreateWidget("completeRowC", xmRowColumnWidgetClass,
  5235.                     parent, ARGLIST);
  5236.     if (pbp->res_show_completion)
  5237.     XtManageChild(rc);
  5238.  
  5239.     /*
  5240.      * Create the job completion notification button
  5241.      */
  5242.     STARTARGS;
  5243.     SETARG(XmNlabelString, pbp->res_complete_label);
  5244.     pbp->complete_label_widget = XtCreateManagedWidget(DEF_COMPLETION_LABEL,
  5245.                     xmLabelWidgetClass,
  5246.                     rc, ARGLIST);
  5247.  
  5248.     /*
  5249.      * Create the notification selection buttons
  5250.      */
  5251.     STARTARGS;
  5252.     SETARG(XmNmarginHeight, 0);
  5253.     SETARG(XmNmarginWidth, 0);
  5254.     bb = XtCreateManagedWidget("completeCheckBB", xmBulletinBoardWidgetClass,
  5255.                     rc, ARGLIST);
  5256.     STARTARGS;
  5257.     SETARG(XmNx, OPTS_INDENT);
  5258.     SETARG(XmNmarginHeight, 0);
  5259.     SETARG(XmNmarginWidth, 0);
  5260.     SETARG(XmNspacing, 0);
  5261.     widget = XmCreateRadioBox(bb, "completeCheck", ARGLIST);
  5262.     XtManageChild(widget);
  5263.  
  5264.     STARTARGS;
  5265.     SETARG(XmNradioBehavior, False);
  5266.     SETARG(XmNindicatorType, XmN_OF_MANY);
  5267.     XtSetValues(widget, ARGLIST);
  5268.  
  5269.     STARTARGS;
  5270.     SETARG(XmNlabelString, pbp->res_complete_mail_label);
  5271.     SETARG(XmNmarginHeight, 0);
  5272.     SETARG(XmNmarginWidth, 0);
  5273.     pbp->complete_mail_widget = XtCreateManagedWidget(DEF_MAIL_LABEL,
  5274.                     xmToggleButtonWidgetClass,
  5275.                     widget, ARGLIST);
  5276.  
  5277.     STARTARGS;
  5278.     SETARG(XmNlabelString, pbp->res_complete_mess_label);
  5279.     SETARG(XmNmarginHeight, 0);
  5280.     SETARG(XmNmarginWidth, 0);
  5281.     pbp->complete_mess_widget = XtCreateManagedWidget(DEF_MESSAGE_LABEL,
  5282.                     xmToggleButtonWidgetClass,
  5283.                     widget, ARGLIST);
  5284. }
  5285.  
  5286.  
  5287. /**************************************************************************
  5288.  *
  5289.  * Function: SetOptionCompletion
  5290.  *
  5291.  * Description: Sets the job completion option based on the resource
  5292.  *
  5293.  * Parameters:
  5294.  *    pbp (I) - this widget's instance part
  5295.  *
  5296.  * Return: none
  5297.  *
  5298.  **************************************************************************/
  5299. /* ARGSUSED */
  5300.  
  5301. static void SetOptionCompletion(PuiPrintBoxPart *pbp)
  5302. {
  5303.     XmToggleButtonSetState(pbp->complete_mail_widget, pbp->res_mail, True);
  5304.     XmToggleButtonSetState(pbp->complete_mess_widget, pbp->res_message, True);
  5305. }
  5306.  
  5307.  
  5308. /**************************************************************************
  5309.  *
  5310.  * Function: GetOptionCompletion
  5311.  *
  5312.  * Description: Gets the completion parameter for the job completion
  5313.  *    option
  5314.  *
  5315.  * Parameters:
  5316.  *    pbp (I) - this widget's instance part
  5317.  *
  5318.  * Return: none
  5319.  *
  5320.  **************************************************************************/
  5321. /* ARGSUSED */
  5322.  
  5323. static void GetOptionCompletion(PuiPrintBoxPart *pbp)
  5324. {
  5325.     if (XmToggleButtonGetState(pbp->complete_mail_widget))
  5326.     pbp->mail = 1;
  5327.     else
  5328.     pbp->mail = 0;
  5329.  
  5330.     if (XmToggleButtonGetState(pbp->complete_mess_widget))
  5331.     AddPrinterOptions(pbp, "-w");
  5332. }
  5333.  
  5334.  
  5335. /**************************************************************************
  5336.  *
  5337.  * Function: SynthGetOptionCompletion
  5338.  *
  5339.  * Description: Updates the completion resource based on the state of the UI
  5340.  *
  5341.  * Parameters:
  5342.  *    w (I) - this widget
  5343.  *    resource_offset (I) - offset of value in instance part
  5344.  *    valuep (O) - value to return
  5345.  *
  5346.  * Return: none
  5347.  *
  5348.  **************************************************************************/
  5349. /* ARGSUSED */
  5350.  
  5351. static void SynthGetOptionCompletion(Widget w, int resource_offset,
  5352.                             XtArgVal *valuep)
  5353. {
  5354.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  5355.  
  5356.     if (resource_offset == offset(printBox.res_mail)) {
  5357.         if (XmToggleButtonGetState(pbp->complete_mail_widget))
  5358.         *valuep = (XtArgVal)True;
  5359.         else
  5360.         *valuep = (XtArgVal)False;
  5361.     } else {
  5362.         if (XmToggleButtonGetState(pbp->complete_mess_widget))
  5363.         *valuep = (XtArgVal)True;
  5364.     else
  5365.         *valuep = (XtArgVal)False;
  5366.     }
  5367. }
  5368.  
  5369.  
  5370. /*
  5371.  --------------------------------------------------------------------------
  5372.             Print File Handling
  5373.  --------------------------------------------------------------------------
  5374. */
  5375.  
  5376.  
  5377. /**************************************************************************
  5378.  *
  5379.  * Function: CreateOptionJobHandling
  5380.  *
  5381.  * Description: Create the print file handling option
  5382.  *
  5383.  * Parameters: 
  5384.  *    pbp (I) - this widget's instance part
  5385.  *    parent (I) - parent widget ID
  5386.  *
  5387.  * Return: none
  5388.  *
  5389.  **************************************************************************/
  5390. /* ARGSUSED */
  5391.  
  5392. static void CreateOptionJobHandling(PuiPrintBoxPart *pbp, Widget parent)
  5393. {
  5394.     Widget widget, rc, bb;
  5395.     DEFARGS(15);
  5396.  
  5397.     /*
  5398.      * Create a vertical RowColumn to put everything in
  5399.      */
  5400.     STARTARGS;
  5401.     SETARG(XmNorientation, XmVERTICAL);
  5402.     SETARG(XmNpacking, XmPACK_TIGHT);
  5403.     rc = XtCreateWidget("handlingRowC", xmRowColumnWidgetClass,
  5404.                     parent, ARGLIST);
  5405.     if (pbp->res_show_handling)
  5406.     XtManageChild(rc);
  5407.  
  5408.     /*
  5409.      * Create the file handling label
  5410.      */
  5411.     STARTARGS;
  5412.     SETARG(XmNlabelString, pbp->res_handling_label);
  5413.     pbp->handling_label_widget = XtCreateManagedWidget(DEF_HANDLING_LABEL,
  5414.                     xmLabelWidgetClass,
  5415.                     rc, ARGLIST);
  5416.  
  5417.     /*
  5418.      * Create the file handling method buttons
  5419.      */
  5420.     STARTARGS;
  5421.     SETARG(XmNmarginHeight, 0);
  5422.     SETARG(XmNmarginWidth, 0);
  5423.     bb = XtCreateManagedWidget("completeCheckBB", xmBulletinBoardWidgetClass,
  5424.                     rc, ARGLIST);
  5425.     STARTARGS;
  5426.     SETARG(XmNx, OPTS_INDENT);
  5427.     SETARG(XmNmarginHeight, 0);
  5428.     SETARG(XmNmarginWidth, 0);
  5429.     SETARG(XmNspacing, 0);
  5430.     widget = XmCreateRadioBox(bb, "handlingRadio", ARGLIST);
  5431.     XtManageChild(widget);
  5432.  
  5433.     STARTARGS;
  5434.     SETARG(XmNlabelString, pbp->res_handling_link_label);
  5435.     SETARG(XmNmarginHeight, 0);
  5436.     SETARG(XmNmarginWidth, 0);
  5437.     pbp->handling_link_widget = XtCreateManagedWidget(DEF_LINK_LABEL,
  5438.                     xmToggleButtonWidgetClass,
  5439.                     widget, ARGLIST);
  5440.  
  5441.     STARTARGS;
  5442.     SETARG(XmNlabelString, pbp->res_handling_copy_label);
  5443.     SETARG(XmNmarginHeight, 0);
  5444.     SETARG(XmNmarginWidth, 0);
  5445.     pbp->handling_copy_widget = XtCreateManagedWidget(DEF_COPY_LABEL,
  5446.                     xmToggleButtonWidgetClass,
  5447.                     widget, ARGLIST);
  5448. }
  5449.  
  5450.  
  5451. /**************************************************************************
  5452.  *
  5453.  * Function: SetOptionJobHandling
  5454.  *
  5455.  * Description: Sets the print file handling option based on the resource
  5456.  *
  5457.  * Parameters:
  5458.  *    pbp (I) - this widget's instance part
  5459.  *
  5460.  * Return: none
  5461.  *
  5462.  **************************************************************************/
  5463. /* ARGSUSED */
  5464.  
  5465. static void SetOptionJobHandling(PuiPrintBoxPart *pbp)
  5466. {
  5467.     if (pbp->res_copy) {
  5468.         XmToggleButtonSetState(pbp->handling_link_widget, False, True);
  5469.         XmToggleButtonSetState(pbp->handling_copy_widget, True, True);
  5470.     } else {
  5471.         XmToggleButtonSetState(pbp->handling_link_widget, True, True);
  5472.         XmToggleButtonSetState(pbp->handling_copy_widget, False, True);
  5473.     }
  5474. }
  5475.  
  5476.  
  5477. /**************************************************************************
  5478.  *
  5479.  * Function: GetOptionJobHandling
  5480.  *
  5481.  * Description: Gets the handling parameter for the print file handling
  5482.  *    option
  5483.  *
  5484.  * Parameters:
  5485.  *    pbp (I) - this widget's instance part
  5486.  *
  5487.  * Return: none
  5488.  *
  5489.  **************************************************************************/
  5490. /* ARGSUSED */
  5491.  
  5492. static void GetOptionJobHandling(PuiPrintBoxPart *pbp)
  5493. {
  5494.     if (XmToggleButtonGetState(pbp->handling_link_widget))
  5495.     pbp->copy_file = 0;
  5496.     else
  5497.     pbp->copy_file = 1;
  5498. }
  5499.  
  5500.  
  5501. /**************************************************************************
  5502.  *
  5503.  * Function: SynthGetOptionJobHandling
  5504.  *
  5505.  * Description: Updates the handling resources based on the state of the
  5506.  *    UI
  5507.  *
  5508.  * Parameters:
  5509.  *    w (I) - this widget
  5510.  *    resource_offset (I) - offset of value in instance part
  5511.  *    valuep (O) - value to return
  5512.  *
  5513.  * Return: none
  5514.  *
  5515.  **************************************************************************/
  5516. /* ARGSUSED */
  5517.  
  5518. static void SynthGetOptionJobHandling(Widget w, int resource_offset,
  5519.                             XtArgVal *valuep)
  5520. {
  5521.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  5522.  
  5523.     if (XmToggleButtonGetState(pbp->handling_link_widget))
  5524.     *valuep = (XtArgVal)False;
  5525.     else
  5526.     *valuep = (XtArgVal)True;
  5527. }
  5528.  
  5529.  
  5530. /*
  5531.  --------------------------------------------------------------------------
  5532.             Printer Specific Options
  5533.  --------------------------------------------------------------------------
  5534. */
  5535.  
  5536.  
  5537. /**************************************************************************
  5538.  *
  5539.  * Function: CreateOptionPrinterSpecific
  5540.  *
  5541.  * Description: Create the printer specific options type in field
  5542.  *
  5543.  * Parameters: 
  5544.  *    pbp (I) - this widget's instance part
  5545.  *    parent (I) - parent widget ID
  5546.  *
  5547.  * Return: none
  5548.  *
  5549.  **************************************************************************/
  5550. /* ARGSUSED */
  5551.  
  5552. static void CreateOptionPrinterSpecific(PuiPrintBoxPart *pbp, Widget parent)
  5553. {
  5554.     Widget rc, bb;
  5555.     DEFARGS(15);
  5556.  
  5557.     /*
  5558.      * Create a vertical RowColumn to put everything in
  5559.      */
  5560.     STARTARGS;
  5561.     SETARG(XmNorientation, XmVERTICAL);
  5562.     SETARG(XmNpacking, XmPACK_TIGHT);
  5563.     rc = XtCreateWidget("specOptionsRowC", xmRowColumnWidgetClass,
  5564.                     parent, ARGLIST);
  5565.     if (pbp->res_show_printeroptions)
  5566.     XtManageChild(rc);
  5567.  
  5568.     /*
  5569.      * Create the label
  5570.      */
  5571.     STARTARGS;
  5572.     SETARG(XmNlabelString, pbp->res_spec_options_label);
  5573.     pbp->spec_options_label_widget = XtCreateManagedWidget(
  5574.                     DEF_PRINTERSPEC_LABEL,
  5575.                     xmLabelWidgetClass,
  5576.                     rc, ARGLIST);
  5577.  
  5578.     /*
  5579.      * Create the printer specific ooptions text entry field
  5580.      */
  5581.     STARTARGS;
  5582.     SETARG(XmNmarginHeight, 0);
  5583.     SETARG(XmNmarginWidth, 0);
  5584.     bb = XtCreateManagedWidget("specOptionsBB", xmBulletinBoardWidgetClass,
  5585.                     rc, ARGLIST);
  5586.     STARTARGS;
  5587.     SETARG(XmNx, OPTS_INDENT);
  5588.     SETARG(XmNcolumns, SPEC_OPTS_COLS);
  5589.     SETARG(XmNmarginHeight, TEXT_FIELD_MAR);
  5590.     SETARG(XmNmarginWidth, TEXT_FIELD_MAR);
  5591.     pbp->spec_options_widget = XtCreateManagedWidget("specOptionsText",
  5592.                     xmTextFieldWidgetClass,
  5593.                     bb, ARGLIST);
  5594. }
  5595.  
  5596.  
  5597. /**************************************************************************
  5598.  *
  5599.  * Function: SetOptionPrinterSpecific
  5600.  *
  5601.  * Description: Sets the printer specific option based on the resource
  5602.  *
  5603.  * Parameters:
  5604.  *    pbp (I) - this widget's instance part
  5605.  *
  5606.  * Return: none
  5607.  *
  5608.  **************************************************************************/
  5609. /* ARGSUSED */
  5610.  
  5611. static void SetOptionPrinterSpecific(PuiPrintBoxPart *pbp)
  5612. {
  5613.     if (pbp->res_spec_opts)
  5614.         XmTextFieldSetString(pbp->spec_options_widget, pbp->res_spec_opts);
  5615.     else
  5616.         XmTextFieldSetString(pbp->spec_options_widget, "");
  5617. }
  5618.  
  5619.  
  5620. /**************************************************************************
  5621.  *
  5622.  * Function: GetOptionPrinterSpecific
  5623.  *
  5624.  * Description: Gets the print parameters for the printer specific
  5625.  *    options
  5626.  *
  5627.  * Parameters:
  5628.  *    pbp (I) - this widget's instance part
  5629.  *
  5630.  * Return: none
  5631.  *
  5632.  **************************************************************************/
  5633. /* ARGSUSED */
  5634.  
  5635. static void GetOptionPrinterSpecific(PuiPrintBoxPart *pbp)
  5636. {
  5637.     char *str, *opt;
  5638.  
  5639.     str = XmTextFieldGetString(pbp->spec_options_widget);
  5640.     if (str && *str) {
  5641.     opt = (char*)malloc(strlen(str) + 10);
  5642.     (void)sprintf(opt, "-o\"%s\"", str);
  5643.     AddPrinterOptions(pbp, opt); 
  5644.     free((char*)opt);
  5645.     }
  5646.     XtFree((char*)str);
  5647. }
  5648.  
  5649.  
  5650. /**************************************************************************
  5651.  *
  5652.  * Function: SynthGetOptionPrinterSpecific
  5653.  *
  5654.  * Description: Updates the printer specific parameter resource based on
  5655.  *    the state of the UI.
  5656.  *
  5657.  * Parameters:
  5658.  *    w (I) - this widget
  5659.  *    resource_offset (I) - offset of value in instance part
  5660.  *    valuep (O) - value to return
  5661.  *
  5662.  * Return: none
  5663.  *
  5664.  **************************************************************************/
  5665. /* ARGSUSED */
  5666.  
  5667. static void SynthGetOptionPrinterSpecific(Widget w, int resource_offset,
  5668.                             XtArgVal *valuep)
  5669. {
  5670.     PuiPrintBoxPart *pbp = &((PuiPrintBoxWidget)w)->printBox;
  5671.  
  5672.     *valuep = (XtArgVal)XmTextFieldGetString(pbp->spec_options_widget);
  5673. }
  5674.  
  5675.  
  5676. /*
  5677.  ==========================================================================
  5678.             PUBLIC AND CONVENIENCE FUNCTIONS
  5679.  ==========================================================================
  5680. */
  5681.  
  5682.  
  5683. /**************************************************************************
  5684.  *
  5685.  * Function: PuiCreatePrintBox
  5686.  *
  5687.  * Description: Creates an unmanaged PrintBox widget.
  5688.  *
  5689.  * Parameters: 
  5690.  *    parent (I) - parent widget ID
  5691.  *    name (I) - instance name for newly created widget
  5692.  *    args (I) - widget resource settings
  5693.  *    num (I) - number of resources specified.
  5694.  *
  5695.  * Return: Widget ID of newly created PrintBox widget.
  5696.  *
  5697.  **************************************************************************/
  5698.  
  5699. Widget PuiCreatePrintBox(Widget parent, String name, ArgList args,
  5700.                 Cardinal num)
  5701. {
  5702.     return XtCreateWidget(name, puiPrintBoxWidgetClass, parent, args, num);
  5703. }
  5704.  
  5705.  
  5706. /**************************************************************************
  5707.  *
  5708.  * Function: PuiCreatePrintDialog
  5709.  *
  5710.  * Description: Creates an unmanaged Dialog Shell and a widget as a child
  5711.  *    of that shell.
  5712.  *
  5713.  * Parameters: 
  5714.  *    parent (I) - parent widget ID
  5715.  *    name (I) - instance name for newly created PrintBox widget
  5716.  *    args (I) - widget resource settings
  5717.  *    num (I) - number of resources specified.
  5718.  *
  5719.  * Return: Widget ID of newly created PrintBox widget.
  5720.  *
  5721.  **************************************************************************/
  5722.  
  5723. Widget PuiCreatePrintDialog(Widget parent, String name, ArgList args,
  5724.                 Cardinal num)
  5725. {
  5726.     Widget ds, pb;
  5727.     ArgList ds_args, pb_args;
  5728.     char *ds_name;
  5729.  
  5730.     /*
  5731.      * Create the DialogShell parent
  5732.      */
  5733.     ds_name = XtCalloc(strlen(name)+XmDIALOG_SUFFIX_SIZE+1, sizeof(char));
  5734.     (void)sprintf(ds_name, "%s%s", name, XmDIALOG_SUFFIX);
  5735.  
  5736.     ds_args = (ArgList)XtMalloc(sizeof(Arg) * (num + 1));
  5737.     (void)memcpy(ds_args, args, sizeof(Arg) * num);
  5738.     XtSetArg(ds_args[num], XmNallowShellResize, True);
  5739.     ds = XtCreatePopupShell(ds_name, xmDialogShellWidgetClass, parent,
  5740.                             ds_args, num + 1);
  5741.  
  5742.     XtFree((char*)ds_args);
  5743.     XtFree(ds_name);
  5744.  
  5745.     /*
  5746.      * Allocate arglist, copy args
  5747.      */
  5748.     pb_args = (ArgList)XtMalloc(sizeof(Arg) * num);
  5749.     (void)memcpy(pb_args, args, sizeof(Arg) * num);
  5750.  
  5751.     /*
  5752.      * Create PrintBox, free args, return
  5753.      */
  5754.     pb = XtCreateWidget(name, puiPrintBoxWidgetClass, ds, pb_args, num);
  5755.     XtAddCallback(pb, XmNdestroyCallback, DestroyParentCB, NULL);
  5756.     XtFree((char*)pb_args);
  5757.  
  5758.     return (pb);
  5759. }
  5760.  
  5761.  
  5762. /**************************************************************************
  5763.  *
  5764.  * Function: PuiPrintBoxGetChild
  5765.  *
  5766.  * Description: Returns the widget ID of the specified PrintBox child
  5767.  *    widget.
  5768.  *
  5769.  * Parameters: 
  5770.  *    w (I) - printBox widget whose child to get
  5771.  *    child (I) - token specifying child whose ID to return.
  5772.  *
  5773.  * Return: Widget ID of the specified child.
  5774.  *
  5775.  **************************************************************************/
  5776.  
  5777. Widget PuiPrintBoxGetChild(Widget w, int child)
  5778. {
  5779.     PuiPrintBoxPart *pbp = &(((PuiPrintBoxWidget)w)->printBox);
  5780.     Widget widget = (Widget)NULL;
  5781.  
  5782.     switch (child) {
  5783.     case PuiPRINTBOX_PRINT_BUTTON:
  5784.         widget = pbp->printb_widget;
  5785.         break;
  5786.     case PuiPRINTBOX_USER1_BUTTON:
  5787.         widget = pbp->user1b_widget;
  5788.         break;
  5789.     case PuiPRINTBOX_USER2_BUTTON:
  5790.         widget = pbp->user2b_widget;
  5791.         break;
  5792.     case PuiPRINTBOX_USER3_BUTTON:
  5793.         widget = pbp->user3b_widget;
  5794.         break;
  5795.     case PuiPRINTBOX_USER4_BUTTON:
  5796.         widget = pbp->user4b_widget;
  5797.         break;
  5798.     case PuiPRINTBOX_OPTIONS_BUTTON:
  5799.         widget = pbp->optionsb_widget;
  5800.         break;
  5801.     case PuiPRINTBOX_SAVE_BUTTON:
  5802.         widget = pbp->saveb_widget;
  5803.         break;
  5804.     case PuiPRINTBOX_CANCEL_BUTTON:
  5805.         widget = pbp->cancelb_widget;
  5806.         break;
  5807.     case PuiPRINTBOX_HELP_BUTTON:
  5808.         widget = pbp->helpb_widget;
  5809.         break;
  5810.     case PuiPRINTBOX_WORK_AREA:
  5811.         widget = pbp->work_area;
  5812.         break;
  5813.     case PuiPRINTBOX_SEPARATOR:
  5814.         widget = pbp->separator;
  5815.         break;
  5816.     default:
  5817.         XtWarning(gettxt(_SGI_LIBPRINTUI_BADCHILD,
  5818.             "PuiPrintBoxGetChild - invalid child token"));
  5819.         break;
  5820.     }
  5821.     return widget;
  5822. }
  5823.  
  5824.  
  5825. /**************************************************************************
  5826.  *
  5827.  * Function: PuiPrintBoxDoPrint
  5828.  *
  5829.  * Description: Convenience function that calls the callback functions on
  5830.  *    the print button callback list. This function simulates the
  5831.  *    pressing of the Print button on the printBox widget action area.
  5832.  *
  5833.  *    Note that the callbacks for the print button will be called with
  5834.  *    the event field of the callback structure set to NULL.
  5835.  *
  5836.  * Parameters: 
  5837.  *    w (I) - printBox widget instance ID
  5838.  *
  5839.  * Return: none
  5840.  *
  5841.  **************************************************************************/
  5842.  
  5843. void PuiPrintBoxDoPrint(Widget w)
  5844. {
  5845.     PuiPrintBoxPart *pbp = &(((PuiPrintBoxWidget)w)->printBox);
  5846.     XmPushButtonCallbackStruct cb;
  5847.  
  5848.     cb.reason = XmCR_ACTIVATE;
  5849.     cb.event = NULL;
  5850.     cb.click_count = 1;
  5851.     XtCallCallbacks(pbp->printb_widget, XmNactivateCallback, (XtPointer)&cb);
  5852. }
  5853.  
  5854.  
  5855. /**************************************************************************
  5856.  *
  5857.  * Function: PuiCvtStringToPrintingPolicy
  5858.  *
  5859.  * Description: Converter for resource type PuiRPrintingPolicy
  5860.  *
  5861.  * Parameters: 
  5862.  *    disp (I) - X connection
  5863.  *    args (I) - arguments to converter
  5864.  *    num_argsp (I) - number of arguments to converter
  5865.  *    from_val (I) - value to convert from
  5866.  *    to_val (O) - converted value
  5867.  *    conv_data (O) - converter specific data
  5868.  *
  5869.  * Return: True if conversion successful and False if conversion not
  5870.  *    successful or too little storage available to store conversion
  5871.  *    result.
  5872.  *
  5873.  **************************************************************************/
  5874. /* ARGSUSED */
  5875.  
  5876. Boolean PuiCvtStringToPrintingPolicy(Display *disp, XrmValuePtr args,
  5877.         Cardinal *num_argsp, XrmValuePtr from_val, XrmValuePtr to_val,
  5878.         XtPointer *conv_data)
  5879. {
  5880.     int policy;
  5881.  
  5882.     /*
  5883.      * This converter does not use any arguments
  5884.      */
  5885.     if (*num_argsp != 0)
  5886.     XtWarning(gettxt(_SGI_LIBPRINTUI_POLICYNOARGS,
  5887.         "PuiCvtStringToPrintingPolicy - no arguments needed"));
  5888.  
  5889.     /*
  5890.      * Determine the printing policy token by comparing the resource
  5891.      * strings (could be done with quarks but not a big deal)
  5892.      */
  5893.     if (!strcmp((char*)from_val->addr, PuiWIDGET_PRINTING_STR))
  5894.     policy = PuiWIDGET_PRINTING;
  5895.     else if (!strcmp((char*)from_val->addr, PuiAPPLICATION_PRINTING_STR))
  5896.     policy = PuiAPPLICATION_PRINTING;
  5897.     else {
  5898.     XtDisplayStringConversionWarning(disp, (char*)from_val->addr,
  5899.                         PuiRPrintingPolicy);
  5900.     return False;
  5901.     }
  5902.  
  5903.     /*
  5904.      * Send the policy value back to the caller. If space has been
  5905.      * allocated, pass the value. Otherwise pass pointer to our
  5906.      * static storage for the value
  5907.      */
  5908.     if (to_val->addr) {
  5909.     if (to_val->size < sizeof(int)) {
  5910.         to_val->size = sizeof(int);
  5911.         return False;
  5912.     }
  5913.     *(int*)(to_val->addr) = policy;
  5914.     } else {
  5915.     static int stat_policy;
  5916.     stat_policy = policy;
  5917.     to_val->addr = (XtPointer)&stat_policy;
  5918.     }
  5919.     to_val->size = sizeof(int);
  5920.  
  5921.     return True;
  5922. }
  5923.  
  5924.  
  5925. /**************************************************************************
  5926.  *
  5927.  * Function: PuiCvtStringToButtonPlacement
  5928.  *
  5929.  * Description: Converter for resource type PuiRButtonPlacement
  5930.  *
  5931.  * Parameters: 
  5932.  *    disp (I) - X connection
  5933.  *    args (I) - arguments to converter
  5934.  *    num_argsp (I) - number of arguments to converter
  5935.  *    from_val (I) - value to convert from
  5936.  *    to_val (O) - converted value
  5937.  *    conv_data (O) - converter specific data
  5938.  *
  5939.  * Return: True if conversion successful and False if conversion not
  5940.  *    successful or too little storage available to store conversion
  5941.  *    result.
  5942.  *
  5943.  **************************************************************************/
  5944. /* ARGSUSED */
  5945.  
  5946. Boolean PuiCvtStringToButtonPlacement(Display *disp, XrmValuePtr args,
  5947.         Cardinal *num_argsp, XrmValuePtr from_val, XrmValuePtr to_val,
  5948.         XtPointer *conv_data)
  5949. {
  5950.     int placement;
  5951.  
  5952.     /*
  5953.      * This converter does not use any arguments
  5954.      */
  5955.     if (*num_argsp != 0)
  5956.     XtWarning(gettxt(_SGI_LIBPRINTUI_BUTTONNOARGS,
  5957.         "PuiCvtStringToButtonPlacement - no arguments needed"));
  5958.  
  5959.     /*
  5960.      * Determine the button palcement by comparing the resource
  5961.      * strings (could be done with quarks but not a big deal)
  5962.      */
  5963.     if (!strcmp((char*)from_val->addr, PuiBUTTONS_LEFT_STR))
  5964.     placement = PuiBUTTONS_LEFT;
  5965.     else if (!strcmp((char*)from_val->addr, PuiBUTTONS_RIGHT_STR))
  5966.     placement = PuiBUTTONS_RIGHT;
  5967.     else if (!strcmp((char*)from_val->addr, PuiBUTTONS_CENTER_STR))
  5968.     placement = PuiBUTTONS_CENTER;
  5969.     else {
  5970.     XtDisplayStringConversionWarning(disp, (char*)from_val->addr,
  5971.                         PuiRButtonPlacement);
  5972.     return False;
  5973.     }
  5974.  
  5975.     /*
  5976.      * Send the placement value back to the caller. If space has been
  5977.      * allocated, pass the value. Otherwise pass pointer to our
  5978.      * static storage for the value
  5979.      */
  5980.     if (to_val->addr) {
  5981.     if (to_val->size < sizeof(int)) {
  5982.         to_val->size = sizeof(int);
  5983.         return False;
  5984.     }
  5985.     *(int*)(to_val->addr) = placement;
  5986.     } else {
  5987.     static int stat_placement;
  5988.     stat_placement = placement;
  5989.     to_val->addr = (XtPointer)&stat_placement;
  5990.     }
  5991.     to_val->size = sizeof(int);
  5992.  
  5993.     return True;
  5994. }
  5995.  
  5996.